Python

Concepts : définition d'une fonction, fonction prédéfinie (buit-in), corps d'une fonction, appel d'une fonction, méthode, constructeur, paramètre, paramètres formels, valeur par défaut, self, paramètres effectifs, mode de passage des paramètres, résultat, None

Concepts avancés : fonction décoratrice (decorator), fonction génératrice

Une fonction, c'est quelque chose :

• que l'on définit ;
  
• et que l'on appelle.

Python, dans son jargon, appelle cela un "callable object", objet appelable. C'est vrai que l'on peut voir une fonction comme une instance et appeler des méthodes sur cette instance (mais, c'est un usage avancé, non traité dans ce cours).

On distingue en Python

• les fonctions définies par l'utilisateur (les vraies fonctions) ;
  
• les méthodes définies par l'utilisateur dans une classe ;
• les fonctions et les méthodes prédéfinies (built-in) ;
• les fonctions génératrices (generator functions) ;
• et d'autres cas bizarres
  

Un premier exemple de fonction ("vraie" fonction)

Une définition de fonction (exemple ci-dessous) :

• sur une première ligne
  
  • introduit un nom pour la fonction fib2 ;
  • indique si cette fonction possède ou nom des paramètres et si oui en donne la liste. La fonction fib2 possède un paramètre de nom (dans le corps de la fonction, on utilise la valeur de n pour contrôler la fin d'une boucle) ;
  • contient le caractère ":"
    
• de façon décalée sur la droite, associe un corps à la fonction.
  
  • Le corps contient les instructions qui seront exécutée à chaque fois que la fonction sera appelée.
    
  • Le corps contient aussi 3 déclarations de variables locales result, a et b (elles existent en autant d'exemplaires différents de la fonction qu'il y a d'appels)
    
  • Le corps de la fonction fib2 contient une instruction return pour rendre un résultat.
    

On ne déclare jamais un seul type

Nulle part, il n'est question de type pour le paramètre n, pour les variables locales a, b et result et pour le résultat renvoyé par l'exécution de la fonction. Python se débrouille.

a et b sont initialisés avec des valeurs entières et on utilise l'opérateur +. On peut déduire que a et b sont des entiers.

n est comparé à a. Le plus logique est que n soit un entier, mais on peut comparer un entier avec un réel!!!!

result est une liste, initialisée avec la liste vide []. Et, via la fonction append, on y met des valeurs entières. On peut donc déduire que result est une liste d'entiers et que donc, la fonction rend une liste d'entiers.

Tout ceci peut être écrit dans une docstring (chaine de documentation entre 3 guillemets de chaque côté). Mais ce n'est pas pour Python que la docString existe, mais pour un être humain qui veut voir clair.

>>> def fib2(n) : # notez les : obligatoires

"""renvoie la liste des nombres de Fibonnaci allant de 0 à n, non compris """

result = []

a, b = 0, 1

while a < n:

result.append(a)

a, b = b, a+b ...

return result

>>> f100 = fib2(100) # appel de la fonction. Le résultat est mis dans f100

>>> print (f100) # Affichage du résultat

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Un deuxième exemple : une fonction récursive

def factorielle (n) :

if n ==0 :

return 0

else :

return n * factorielle (n-1)

Notez que c'est de la responsabilité du programmeur de passe un entier positif à cette fonction. factorielle(-3) et factorielle (1.2) contiennent une boucle infinie

Une fonction peut avoir 0 ou plusieurs paramètres, rendre 0, 1 ou plusieurs résultats

Pas de paramètres

Même si n'y a pas de paramètres, il faut mettre des parenthèses à la fois dans la définition et l'appel.

def imprimer_heure () :

print ("on verra comment faire plus tard")

Rendre un résultat

On peut écrire return 7 (la fonction se termine et rend la valeur 7. Le résultat n'est pas obligatoire simple. On peut rendre une séquence, un ensemble un dictionnaire, une instance d'objets

Rendre aucun résultat

Elle peut aussi se terminer simplement par une instructions return sans expression. Dans ce cas, un objet très spécial est renvoyé None.

C'est aussi le cas si une fonction se termine sans avoir exécuté une instruction return.

On peut aussi écrire :

return None

Plus d'un résultat

def f() :

...
return exp1, exp2, exp3

x, y, z = f()

Les paramètres peuvent avoir des valeurs par défaut

On reprend un peut tout cela dans entrées du glossaire : paramètre, paramètre formel, paramètre effectif

Les paramètres formels possédant une valeur par défaut doivent suivre les paramètres sans valeurs par défaut dans la définition de la fonction.

def est_divisible_par(nombre, diviseur =2):

return nombre%diviseur == 0

Appels possibles (1 ou 2 paramètres effectifs) :

est_divisible_par(4)

est_divisible_par(5, 3)

Le langage Python permet d'avoir des paramètres effectifs en nombre quelconque

Il s'agit des notations *args et **kwds dans la définition d'une fonction.
Cf les entrées paramètre, paramètre formel et paramètre effectif

FAQ

1) J'ai oublié de mettre les parenthèses pour appeler une fonction f sans paramètres. J'ai écrit f. Python ne m'a rien dit et est passé à l'exécution de l'instruction suivant. Pourquoi? Il aurait pu me dire qu'il y avait une erreur.

2)