Python fr:Fonctions

[edit] Introduction

Les fonctions sont des morceaux re-utilisables de programmes. Ils vous permettent de donner un nom à un bloc d'instructions et vous pouvez exécuter ce bloc n'importe où et autant de fois que vous le voulez. C'est ce qu'on nomme appeler la fonction. Nous avons déjà utilisé des fonctions intégrées comme len et range.

Le concept de fonction est probablement le plus important bloc de base de n'importe quel logiciel un peu complexe (dans n'importe quel langage), donc nous explorerons divers aspects des fonctions dans ce chapitre.

Les fonctions sont définies en utilisant le mot-clé def . Cela est suivi par un nom d' identifier pour la fonction suivi d'une paire de parenthèses qui peuvent inclure des noms de variables et la ligne se termine par un caractère deux-points. Puis suit un bloc d'instructions qui font partie de la fonction. Un exemple va montrer que cela est en fait très simple :

Exemple:

#!/usr/bin/python
# Nom de fichier : function1.py
 
def sayHello():
    print('Hello World!') # bloc appartenant à la fonction
# Fin de la fonction
 
sayHello() # appel de la fonction
sayHello() # nouvel appel de la fonction

Résultat :

   $ python function1.py
   Hello World!
   Hello World!

Comment cela fonctionne :

Nous avons défini une fonction appelée sayHello qui utilise la syntaxe expliquée ci-dessus. La fonction ne prend pas de paramètre et donc il n'y a pas de variables déclarées entre les parenthèses. Les paramètres d'une fonctions sont juste des données en entrée de la fonction afin de passer des valeurs et de récupérer les résultats correspondants.

Notez que nous pouvons appeler la même fonction deux fois ce qui implique que nous n'avons pas à écrire le même code à nouveau.

[edit] Les Paramètres D'Une Fonction

Une fonction peut prendre des paramètres, qui sont des valeurs fournies à la fonction afin que la fonction fasse quelque chose en utilisant ces valeurs. Ces paramètres sont comme des variables, sauf que les valeurs de ces variables sont définies quand nous appelons la fonction et ont déjà des valeurs assignées quand la fonction est exécutée.

Les paramètres sont spécifiés à l'intérieur de la paire de parenthèses de la définition de la fonction, séparées par des virgules. Quand nous appelons la fonction, nous fournissons les valeurs de la même manière. Notez la terminologie utilisée - les noms donnés dans la définition de la fonction sont appelés des paramètres quand les valeurs que vous fournissez à l'appel de la fonction sont des arguments.

Exemple:

#!/usr/bin/python
# Nom de fichier : func_param.py
 
def printMax(a, b):
    if a > b:
        print(a, 'est plus grand')
    elif a == b:
        print(a, 'est égal à', b)
    else:
        print(b, 'est plus grand')
 
printMax(3, 4) # affiche directement un résultat littéral
 
x = 5
y = 7
 
printMax(x, y) # fournit des variables en tant qu'arguments

Résultat:

   $ python func_param.py
   4 est plus grand
   7 est plus grand

Comment cela fonctionne :

Ici, nous définissons une fonction appelée printMax qui prend deux paramètres appelés a et b. Nous trouvons le nombre le plus grand en utilsiant une simple instruction if..else et nous l'affichons.

Dans la première utilisation de printMax, nous fournissons directement les nombres, c'est-à-dire les arguments. Dans la deuxième utilisation, nous appelons la fonction en utilisant des variables. printMax(x, y) fait que la valeur de l'argument x est assignée au paramètre a et la valeur de l'argument y assignée au paramètre b. La fonction printMax agit de la même manière dans les deux cas.

[edit] Variables Locales

Quand vous déclarez des variables à l'intérieur de la définition d'une fonction, elles ne sont en aucun cas en rapport avec d'autres variables portant le même nom, utilisées en dehors de la fonction, c'est-à-dire que les noms de variables sont locaux à la fonction. Cela est appelé le scope de la variable. Toutes les variables ont le scope du bloc dans lequel elles sont déclarées, à partir du point de définition du nom.

Exemple:

#!/usr/bin/python
# Nom du fichier : func_local.py
 
x = 50
 
def func(x):
    print('x est', x)
    x = 2
    print('Nous avons changé le x local à', x)
 
func(x)
print('x est toujours', x)

Résultat :

   $ python func_local.py
   x est 50
   Nous avons changé le x local à 2
   x est toujours 50

Comment cela fonctionne :

Dans cette fonction, la première fois que nous utilisons la valeur de nom x, Python utilise la valeur du paramètre déclaré dans la fonction.

Ensuite, nous assignons la valeur 2 à x. Le nom x est local à notre fonction. Donc, quand nous changeons la valeur de x dans la fonction, le x défini dans le bloc principal n'est pas modifié.

Dans le dernier appel de la fonction print , nous affichons la valeur de x dans le bloc principal et confirmons qu'elle n'a pas été modifiée.

[edit] Utiliser L'Instruction Global

Si vous voulez assigner une valeur à un nom défini au niveau supérieur de votre programme (c'est-à-dire en dehors du scope de n'importe quelle fonction ou classe), alors vous devez indiquer à Python que ce nom n'est pas local, mais qu'il est global. Vous faites cela avec l'instruction global . Il est impossible d'assigner une valeur à une variable définie en dehors d'une fonction sans l'instruction global .

Vous pouvez utiliser les valeurs de telles variables définies en dehors d'une fonction (en supposant qu'il n'existe pas de variable avec le même nom à l'intérieur de la fonction). Cependant, cela est déconseillé et devrait être évité car le programme devient confus et le lecteur ne sait plus où est la définition de la variable. Utiliser l'instruction global indique clairement que la variable est définie dans un bloc éloigné.

Exemple:

#!/usr/bin/python
# Nom de fichier : func_global.py
 
x = 50
 
def func():
    global x
 
    print('x vaut', x)
    x = 2
    print('Nous avons changé la valeur de la variable globale x à', x)
 
func()
print('x vaut', x)

Résultat :

   $ python func_global.py
  x vaut 50
  Nous avons changé la valeur de la variable globale x à 2
  x vaut 2

Comment cela fonctionne : L'instruction global est utilisée pour déclarer que x est une variable globale - d'où, quand nous assignons une valeur à x à l'intérieur de la fonction, ce changement est mis en évidence quand nous utilisons la valeur de x dans le bloc principal .

Vous pouvez déclarer plusieurs variables globales en utilisant la même instruction global . Par exemple, global x, y, z.

[edit] Utiliser Des Instructions Non Locales

Nous avons vu précédemment comment accéder des variables de portée locale et globale. Il y a un autre type de portée appelé "nonlocal" qui est entre les deux. Les portées non locales sont observées quand vous définissez des fonctions à l'intérieur de fonctions.

Comme tout est juste du code exécutable en Python, vous pouvez définir des fonctions n'importe où.

Prenons un exemple:

#!/usr/bin/python
# Nom de fichier : func_nonlocal.py
 
def func_outer():
    x = 2
    print('x est', x)
 
    def func_inner():
        nonlocal x
        x = 5
 
    func_inner()
    print('Nous avons changé le x local à', x)
 
func_outer()

Résultat :

   $ python func_nonlocal.py
   x est 2
   Nous avons changé le x local à 5

Comment cela fonctionne :

Quand nous sommes à l'intérieur de func_inner, le 'x' défini dans la première ligne de func_outer n'est ni de portée locale ni de portée globale. Nous déclarons que nous utilisons ce x avec nonlocal x et donc nous avons accès à cette variable.

Essayez de changer le nonlocal x en global x et aussi d'enlever l'instruction elle-même et observez la différence de comportement dans les deux cas.

[edit] Default Argument Values

Pour certaines fonctions, vous voudrez que certains de ses paramètres soient optionnels et utilisent des valeurs par défaut si l'utilisateur ne fournit pas de valeurs pour ces paramètres. Cela est fait avec des default argument values. Vous pouvez spécifier des default argument values pour des paramètres en faisant suivre le nom du paramètre dans la définition de la fonction par l'opérateur d'assignement (=) suivi de la valeur par défaut.

Notez que la valeur d'argument par défaut doit être une constante. Plus précisément, la valeur d'argument par défaut doit être immuable - cela est expliqué en détail dans des chapitres ultérieurs. Pour l'instant, retenez juste ce qui précède.

Exemple:

#!/usr/bin/python
# Nom de fichier : func_default.py
 
def say(message, nbfois = 1):
    print(message * nbfois)
 
say('Hello')
say('World', 5)

Résultat :

   $ python func_default.py
   Hello
   WorldWorldWorldWorldWorld

Comment cela fonctionne :

Le nom de la fonction say est utilisé pour afficher une chaîne de caractères autant de fois qu'indiqué. Si nous ne fournissons pas de valeur pour ce nombre de fois, alors par défaut la chaîne de caractères est affichée juste une fois. Nous obtenons ceci en indiquant une valeur par défaut de 1 pour le paramètre nbfois.

Au premier appel de say, nous fournissons seulement la chaîne de caractères et elle est imprimée une fois. Au deuxième appel de say, nous fournissons à la fois la chaîne de caractères et un argument 5 indiquant que nous voulons dire (say) le message de la chaîne de caractères 5 fois.

Important

Seuls les paramètres à la fin de la liste de paramètres peuvent recevoir une valeur par défaut, c'est-à-dire que vous ne pouvez avoir un paramètre avec une valeur par défaut avant un paramètre sans valeur par défaut dans la liste des paramètres de la fonction.

La raison est que les valeurs sont assignées aux paramètres par position. Par exemple, def func(a, b=5) est valide, mais def func(a=5, b) n'est pas valide.

[edit] Paramètres Nommés

Si vous avez des fonctions avec de nombreux paramètres et que vous en spécifiez seulement certains, vous pouvez donner des valeurs à ces paramètres en les nommant - cela est appelé Paramètres Nommés - nous utilisons le nom (mot-clé) au lieu de la position (que nous avons utilisée jusque-là) pour spécifier les arguments de la fonction.

Il y a deux avantages - un, utiliser la fonction est plus facile car nous n'avons pas à nous soucier de l'ordre des paramètres. Deux, nous pouvons donner des valeurs seulement aux paramètres que nous voulons, en supposant que les autres paramètres ont des valeurs par défaut.

Exemple:

#!/usr/bin/python
# Nom de fichier : func_key.py
 
def func(a, b=5, c=10):
    print('a vaut', a, 'et b vaut', b, 'et c vaut', c)
 
func(3, 7)
func(25, c=24)
func(c=50, a=100)

Résultat :

   $ python func_key.py
   a vaut 3 et b vaut 7 et c vaut 10
   a vaut 25 et b vaut 5 et c vaut 24
   a vaut 100 et b vaut 5 et c vaut 50

Comment cela fonctionne :

La fonction func a un paramètre par défaut sans valeur, suivi de deux paramètres avec des valeurs par défaut.

Dans le premier cas, func(3, 7), le paramètre a prend la valeur 3, le paramètre b la valeur 7 et c la valeur par défaut 10.

Dans le deuxième cas, func(25, c=24), la variable a prend la valeur 25 à cause de la position du paramètre. Ensuite, le paramètre c prend la valeur 24 à cause du nom des paramètres. La variable b prend la valeur par défaut de 5.

Dans le troisième cas, func(c=50, a=100), nous utilisons le mot-clé argument pour spécifier les valeurs. Notez que nous spécifions la valeur du paramètre c avant celle de a même si a est défini avant c dans la définition de la fonction.

[edit] VarArgs Parameters

TODO

Devrais-je en parler ici ou dans un chapitre suivant, comme nous n'avons pas encore parlé de listes et de dictionnaires ?

Vous voudrez parfois définir une fonction qui peut prendre n'importe quel nombre de paramètres, cela peut être obtenu en utilisant les paramètres arbitraires :

#!/usr/bin/python
# Nom du fichier : total.py
 
def total(initial=5, *nombres, **motscles):
    count = initial
    for nombres in nombres:
        count += nombres
    for key in motscles:
        count += motscles[key]
    return count
 
print(total(10, 1, 2, 3, legumes=50, fruits=100))

Résultat :

   $ python total.py
   166

Comment cela fonctionne :

Quand nous déclarons un paramètre arbitraire comme *param, alors tous les paramètres à partir de cette position jusqu'à la fin sont regroupés dans un tuple appelé 'param'.

De la même manière, quand nous déclarons un paramètre non-explicite comme **param, alors tous les mots-clés jusqu'à la fin sont regroupés dans un dictionnaire appelé 'param'.

Nous explorerons les tuples et les dictionnaires dans un chapitre suivant.

[edit] Paramètres Arbitraires

Si vous voulez déclarer que certains keyword parameters sont disponibles en tant que keyword-only et pas en tant que paramètre positionnel, il faut le faire en tant que paramètre arbitraire :

#!/usr/bin/python
# Nom de fichier : keyword_only.py
 
def total(initial=5, *nombres, nombre_en_plus):
    count = initial
    for nombres in nombres:
        count += nombres
    count += nombre_en_plus
    print(count)
 
total(10, 1, 2, 3, nombre_en_plus=50)
total(10, 1, 2, 3)
# Lève une erreur parce que nous n'avons pas fourni une valeur par défaut pour 'nombre_en_plus'

Résultat :

   $ python keyword_only.py
   66

Traceback (most recent call last):

   File keyword_only.py, line 13, in <module>
   total(10, 1, 2, 3)

TypeError: total() needs keyword-only argument nombre_en_plus

Comment cela fonctionne:

Le fait de déclarer des paramètres après un paramètre arbitraire fait que l'on a des keyword-only arguments. Si ces arguments n'ont pas une valeur par défaut, alors un appel à la fonction va lever une erreur si le keyword argument n'est pas fourni, comme vu précédemment.

Notez l'usage de += qui est un raccourci pour un opérateur, donc au lieu de dire x = x + y, vous pouvez dire x += y.

Si vous voulez avoir des keyword-only arguments mais n'avez pas besoin de paramètre arbitraire, alors utilisez simplement un empty star sans le moindre nom, def total(initial=5, *, extra_number).

[edit] L'Instruction Return

L'instruction return est utilisée pour revenir d'une fonction, c'est à dire sortir de la fonction. Vous pouvez optionnellement retourner une valeur de la fonction.

Exemple:

#!/usr/bin/python
# Nom de fichier : func_return.py
 
def maximum(x, y):
    if x > y:
        return x
    elif x == y:
        print('Les nombres sont égaux')
    else:
        return y
 
print(maximum(2, 3))

Résultat :

   $ python func_return.py
   3

Comment cela fonctionne :

La fonction maximum renvoie la valeur maximum des paramètres, dans ce cas les nombres fournis à la fonction. Elle utilise une simple instruction if..else pour trouver la plus grand valeur et ensuite retourne cette valeur.

Notez qu'une instruction return sans une valeur est équivalente à return None. None est un type spécial en Python, qui représente nothingness. Par exemple, il est utilisé pour indiquer qu'une valeur n'a pas de valeur, si elle a une valeur de None.

Chaque fonction contient implicitement une instruction return None à la fin, à moins que vous ayez écrit votre propre instruction return . Vous pouvez voir cela en lançant print(someFunction()) où la fonction someFunction n'utilise pas l'instruction return comme:

def someFunction():
    pass

L'instruction pass est utilisée en Python pour indiquer un bloc d'instructions vide.

Note

Il y a une fonction intégrée appelée max qui implémente déjà la fonctionnalité 'trouver le maximum', donc utilisez-là de préférence autant que possible.

[edit] DocStrings

Python a une chouette fonctionnalité appelée documentation strings, communément appelée docstrings. Les DocStrings sont un outil important que vous devriez utiliser, car cela vous aide à mieux documenter le programme et le rend plus facile à comprendre. Nous pouvons même récuperer les docstrings en revenant, disons d'une fonction, pendant que le programme s'exécute !

Exemple:

#!/usr/bin/python
# Nom de fichier : func_doc.py
 
def printMax(x, y):
    '''Affiche le plus grand de deux nombres
 
    Les deux valeurs doivent être des entiers.'''
    x = int(x) # conversion vers un entier, si possible
    y = int(y)
 
    if x > y:
        print (x,'est le plus grand')
    else:
        print (y,'est le plus grand')
 
printMax(3, 5)
print(printMax.__doc__)

Résultat :

   $ python func_doc.py
   5 est le plus grand
   Affiche le plus grand de deux nombres

   Les deux valeurs doivent être des entiers.

Comment cela fonctionne :

Une chaîne de caractères sur la première ligne logique de la fonction est la docstring pour cette fonction. Notez que les docstrings s'appliquent aussi aux modules et aux classes que nous verrons dans les chapitres suivants.

La convention pour une docstring est une chaîne de caractères sur plusieurs lignes, la première ligne commençant avec une majuscule et se terminant par un point. La deuxième ligne est vide suivie par une explication détaillée commençant sur la troisième ligne. Vous êtes fortement invité à suivre cette convention pour toutes vos docstrings pour toutes vos fonctions non-triviales.

Nous pouvons accéder la docstring de la fonction printMax en utilisant les attributs (nom appartenant à) __doc__ (notez les double underscores) de la fonction. Souvenez-vous juste que Python traite tout en tant qu'objet et cela inclut les fonctions. Nous en apprendrons plus sur les objets dans un prochain chapitre sur les classes.

Si vous avez utilisé help() en Python, alors vous avez déjà utilisé les docstrings! Les Docstrings vont juste chercher l'attribut __doc__ de la fonction et vous l'affichent d'une manière propre. Vous pouvez essayer sur la fonction au-dessus - incluez juste help(printMax) dans votre programme. Souvenez-vous d'appuyer sur q pour sortir du help.

Les Automated Tools peuvent récupérer la documentation de votre programme de cette manière. Cependant, je recommande fortement que vous utilisiez les docstrings pour tout fonction non-triviale que vous écrivez. La commande pydoc qui vient avec votre distribution Python fonctionne de manière similaire au help() en utilisant les docstrings.

[edit] Annotations

Les fonctions ont une autre fonctionnalité avancée appelée annotations, qui sont une chouette manière de joindre de l'information supplémentaire pour chaque paramètre et chaque valeur de retour. Comme le langage Python lui-même n'interprète pas ces annotations de quelque manière que ce soit (cette fonctionnalité est laissée aux librairies tierces d'interpréter de la manière qu'elles le veulent), nous sauterons cette fonctionnalité dans notre discussion. Si vous êtes intéressé par la lecture de ces annotations, voyez Python Enhancement Proposal No. 3107.

[edit] Récapitulatif

Nous avons vu de nombreux aspects des fonctions mais il nous reste des choses à voir. Cependant nous avons vu l'essentiel de ce que vous utiliserez couramment concernant les fonctions dans Python.

Nous allons maintenant voir comment créer des modules Python.