Python - Fonctions

Une fonction est un bloc de code organisé et réutilisable utilisé pour effectuer une seule action associée. 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éfinition d'une fonction

Vous pouvez définir des fonctions pour fournir les fonctionnalités requises. 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, renvoyant éventuellement une expression à l'appelant. Une instruction return sans argument équivaut à 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 informer 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'imprime sur l'écran standard.

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

Appeler une fonction

La définition d'une fonction ne lui donne qu'un nom, spécifie les paramètres qui doivent être inclus 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 () -

#!/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 -

#!/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 conservons 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.

#!/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. Changer ma liste dans la fonction n'affecte pas ma liste . 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 fonction

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

• Arguments requis
• Arguments de 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 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 -

#!/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 mot-clé 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 des paramètres. Vous pouvez également effectuer des appels de mots-clés à la fonction printme () des manières suivantes -

#!/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.

#!/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 une valeur n'est pas fournie dans l'appel de fonction pour cet argument. L'exemple suivant donne une idée sur les arguments par défaut, il imprime l'âge par défaut s'il n'est pas passé -

#!/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é lors de la définition de la fonction. Ces arguments sont appelés arguments de longueur variable 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 de variable sans 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 variable non-mot clé. Ce tuple reste vide si aucun argument supplémentaire n'est spécifié lors de l'appel de fonction. Voici un exemple simple -

#!/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

Les fonctions anonymes

Ces fonctions sont appelées anonymes car elles ne sont pas déclarées de manière standard à l'aide du mot clé def . Vous pouvez utiliser le mot clé lambda 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 ni d'expressions multiples.

• Une fonction anonyme ne peut pas être un appel direct à imprimer 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'appel pour des raisons de performances.

Syntaxe

La syntaxe des fonctions lambda ne contient qu'une seule instruction, qui est la suivante -

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

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

#!/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

La déclaration de retour

L'instruction return [expression] quitte une fonction, renvoyant éventuellement une expression à l'appelant. Une instruction return sans argument équivaut à return None.

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

#!/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 dans laquelle vous pouvez accéder à un identifiant particulier. Il existe deux étendues de base de variables en Python -

• Variables globales
• Variables locales

Variables globales et 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 sont placées dans la portée. Voici un exemple simple -

#!/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