Python - Fonctions

Page PrécédentePage Suivante

Une fonction est un bloc de code organisé et réutilisable qui est utilisé pour effectuer une seule action connexe. Les fonctions offrent une meilleure modularité pour votre application et un degré élevé de réutilisation du code.

Comme vous le savez déjà, Python vous offre de nombreuses fonctions intégrées comme print(), etc. mais vous pouvez également créer vos propres fonctions. Ces fonctions sont appelées fonctions définies par l'utilisateur.

Définir une fonction

Vous pouvez définir des fonctions pour fournir la fonctionnalité requise. Voici des règles simples pour définir une fonction en Python.

• Les blocs fonctionnels commencent par le mot-clé def suivi du nom de la fonction et des parenthèses ( ( ) ).

• Tous les paramètres ou arguments d'entrée doivent être placés entre ces parenthèses. Vous pouvez également définir des paramètres à l'intérieur de ces parenthèses.

• La première instruction d'une fonction peut être une instruction facultative - la chaîne de documentation de la fonction ou docstring .

• Le bloc de code dans chaque fonction commence par deux-points (:) et est indenté.

• L'instruction return [expression] quitte une fonction, en renvoyant éventuellement une expression à l'appelant. Une instruction return sans arguments est identique à return None.

Syntaxe

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

Par défaut, les paramètres ont un comportement positionnel et vous devez les renseigner dans le même ordre qu'ils ont été définis.

Exemple

La fonction suivante prend une chaîne comme paramètre d'entrée et l'affiche sur l'écran standard.

def printme( str ):
   "This prints a passed string into this function"
   print str
   return

Appeler une fonction

Définir une fonction ne lui donne qu'un nom, précise les paramètres à inclure dans la fonction et structure les blocs de code.

Une fois la structure de base d'une fonction finalisée, vous pouvez l'exécuter en l'appelant depuis une autre fonction ou directement depuis l'invite Python. Voici l'exemple pour appeler la fonction printme() −

Démo en direct

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

I'm first call to user defined function!
Again second call to the same function

Passer par référence vs valeur

Tous les paramètres (arguments) du langage Python sont passés par référence. Cela signifie que si vous modifiez ce à quoi un paramètre fait référence dans une fonction, le changement se reflète également dans la fonction appelante. Par exemple −

Démo en direct

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Ici, nous maintenons la référence de l'objet passé et ajoutons des valeurs dans le même objet. Donc, cela produirait le résultat suivant −

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

Il existe un autre exemple où l'argument est passé par référence et la référence est écrasée à l'intérieur de la fonction appelée.

Démo en direct

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig new reference in mylist
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Le paramètre mylist est local à la fonction changeme. La modification de mylist dans la fonction n'affecte pas mylist . La fonction n'accomplit rien et finalement cela produirait le résultat suivant −

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

Arguments de la fonction

Vous pouvez appeler une fonction en utilisant les types d'arguments formels suivants −

• Arguments obligatoires
• Arguments des mots clés
• Arguments par défaut
• Arguments de longueur variable

Arguments requis

Les arguments requis sont les arguments passés à une fonction dans l'ordre de position correct. Ici, le nombre d'arguments dans l'appel de la fonction doit correspondre exactement à la définition de la fonction.

Pour appeler la fonction printme() , vous devez absolument passer un argument, sinon cela donne une erreur de syntaxe comme suit −

Démo en direct

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme()

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Arguments de mots clés

Les arguments de mot-clé sont liés aux appels de fonction. Lorsque vous utilisez des arguments de mots clés dans un appel de fonction, l'appelant identifie les arguments par le nom du paramètre.

Cela vous permet d'ignorer les arguments ou de les placer dans le désordre car l'interpréteur Python est capable d'utiliser les mots-clés fournis pour faire correspondre les valeurs avec les paramètres. Vous pouvez également faire des appels de mots-clés à printme() fonctionner de la manière suivante −

Démo en direct

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme( str = "My string")

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

My string

L'exemple suivant donne une image plus claire. Notez que l'ordre des paramètres n'a pas d'importance.

Démo en direct

#!/usr/bin/python

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

Name:  miki
Age  50

Arguments par défaut

Un argument par défaut est un argument qui prend une valeur par défaut si aucune valeur n'est fournie dans l'appel de fonction pour cet argument. L'exemple suivant donne une idée des arguments par défaut, il imprime l'âge par défaut s'il n'est pas passé −

Démo en direct

#!/usr/bin/python

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

Name:  miki
Age  50
Name:  miki
Age  35

Arguments de longueur variable

Vous devrez peut-être traiter une fonction pour plus d'arguments que vous n'en avez spécifiés lors de la définition de la fonction. Ces arguments sont appelés variable-length arguments et ne sont pas nommés dans la définition de la fonction, contrairement aux arguments obligatoires et par défaut.

La syntaxe d'une fonction avec des arguments variables non-mot-clé est la suivante -

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

Un astérisque (*) est placé avant le nom de la variable qui contient les valeurs de tous les arguments de variables autres que les mots-clés. Ce tuple reste vide si aucun argument supplémentaire n'est spécifié lors de l'appel de la fonction. Voici un exemple simple −

Démo en direct

#!/usr/bin/python

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print "Output is: "
   print arg1
   for var in vartuple:
      print var
   return;

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

Output is:
10
Output is:
70
60
50

Le Anonyme Fonctions

Ces fonctions sont dites anonymes car elles ne sont pas déclarées de manière standard en utilisant le def mot-clé. Vous pouvez utiliser le lambda mot-clé pour créer de petites fonctions anonymes.

• Les formulaires Lambda peuvent prendre n'importe quel nombre d'arguments mais ne renvoient qu'une seule valeur sous la forme d'une expression. Ils ne peuvent pas contenir de commandes ou d'expressions multiples.

• Une fonction anonyme ne peut pas être un appel direct à print car lambda nécessite une expression

• Les fonctions Lambda ont leur propre espace de noms local et ne peuvent pas accéder à des variables autres que celles de leur liste de paramètres et celles de l'espace de noms global.

• Bien qu'il semble que les lambda soient une version sur une ligne d'une fonction, ils ne sont pas équivalents aux instructions en ligne en C ou C++, dont le but est de transmettre l'allocation de la pile de fonctions lors de l'invocation pour des raisons de performances.

Syntaxe

La syntaxe de lambda functions ne contient qu'une seule instruction, qui est la suivante −

lambda [arg1 [,arg2,.....argn]]:expression

Voici l'exemple pour montrer comment lambda forme de fonction fonctionne −

Démo en direct

#!/usr/bin/python

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;

# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

Value of total :  30
Value of total :  40

Le retour Déclaration

L'instruction return [expression] quitte une fonction, en renvoyant éventuellement une expression à l'appelant. Une instruction return sans arguments est identique à return None.

Tous les exemples ci-dessus ne renvoient aucune valeur. Vous pouvez renvoyer une valeur à partir d'une fonction comme suit −

Démo en direct

#!/usr/bin/python

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total 

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

Inside the function :  30
Outside the function :  30

Portée des variables

Toutes les variables d'un programme peuvent ne pas être accessibles à tous les emplacements de ce programme. Cela dépend de l'endroit où vous avez déclaré une variable.

La portée d'une variable détermine la partie du programme où vous pouvez accéder à un identificateur particulier. Il existe deux portées de base des variables en Python −

• Variables globales
• Variables locales

Variables globales et variables locales

Les variables définies à l'intérieur d'un corps de fonction ont une portée locale, et celles définies à l'extérieur ont une portée globale.

Cela signifie que les variables locales ne sont accessibles qu'à l'intérieur de la fonction dans laquelle elles sont déclarées, tandis que les variables globales sont accessibles dans tout le corps du programme par toutes les fonctions. Lorsque vous appelez une fonction, les variables déclarées à l'intérieur de celle-ci sont mises en portée. Voici un exemple simple −

Démo en direct

#!/usr/bin/python

total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;

# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total 

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

Inside the function local total :  30
Outside the function global total :  0