You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
This repo is archived. You can view files and clone it, but cannot push or open issues/pull-requests.
 
 
 
 
 
 

168 line
4.1 KiB

  1. Jouons avec les fonctions
  2. =========================
  3. Introduction
  4. ------------
  5. Reprenons ce qu'on a vu jusqu'ici.
  6. D'une part, on peut créer des variables en les assignant à une valeur::
  7. # Création d'une variable `x` avec la valeur 4
  8. x = 4
  9. On dit aussi que ``x`` *référence* la valeur ``4``
  10. D'autre part, on peut définir et appeler des fonctions::
  11. # Définition de la fonction:
  12. def dire_bonjour(nom):
  13. print("Bonjour " + nom)
  14. # Appel
  15. dire_bonjour("Max")
  16. # Affiche: "Bonjour Max"
  17. Fonctions en tant que variables
  18. -------------------------------
  19. Il se trouve qu'en Python, on peut assigner des variables à ... des fonctions
  20. .. code-block:: python
  21. # Définition d'une fonction `dire_bonjour_en_français`
  22. def dire_bonjour_en_français(nom):
  23. print("Bonjour " + nom)
  24. # Définition d'une fonction `dire_bonjour_en_anglais`
  25. def dire_bonjour_en_anglais(nom):
  26. print("Hello " + nom)
  27. # Création d'une variable qui référence la fonction française:
  28. ma_fonction_qui_dit_bonjour = dire_bonjour_en_français
  29. # Appel de la fonction:
  30. ma_fonction_qui_dit_bonjour("Max")
  31. # Affiche: Bonjour Max
  32. De façon cruciale, notez que l'on n'a *pas* mis de parenthèses à droite
  33. lorsqu'on a créé la variable `ma_fonction_qui_dit_bonjour`.
  34. On peut donc dire que lorsqu'on définit une fonction avec `def()` et un corps
  35. il y a en réalité deux étapes:
  36. 1. Python stocke le corps de la fonction quelque part
  37. 2. Il crée une variable qui référence ce corps
  38. En Python, il est assez fréquent d'utiliser de code tel que celui-ci, souvent avec un dictionnaire::
  39. fonctions_connues = {
  40. "français": dire_bonjour_en_français,
  41. "anglais": dire_bonjour_en_anglais,
  42. }
  43. # Ici on stocke la langue parlée par l'utilisateur
  44. # et son prénom
  45. langue_parlée = ...
  46. prénom = ....
  47. if langue_parlée in fonctions_connues:
  48. fonction = fonctions_connues[langue_parlée]
  49. fonction(prénom)
  50. Fonctions en tant qu'argement d'autres fonctions
  51. ------------------------------------------------
  52. On a vu en début de chapitre qu'on peut créé des variables qui référencent
  53. des fonctions.
  54. Du coup, rien n'empêche de les passer en *argument* d'autres fonctions.
  55. Par exemple::
  56. def appelle_deux_fois(f):
  57. f()
  58. f()
  59. def crier():
  60. print("Aline !")
  61. appelle_deux_fois(crier)
  62. # Affiche:
  63. # Aline !
  64. # Aline !
  65. Fonctions imbriquées
  66. --------------------
  67. On peut aussi définir une fonction dans une autre fonction::
  68. def affiche_message(message):
  69. def affiche():
  70. print(message)
  71. affiche()
  72. affiche_message("Bonjour")
  73. # affiche: Bonjour
  74. Deux notes importantes:
  75. Premièrement, la fonction `affiche()` qui est imbriquées dans `affiche_message()` n'est pas
  76. accessible à l'éxtérieur de la fonction qui la contient. En d'autres termes, ce code
  77. ne fonctionne pas::
  78. def affiche_message(message):
  79. def affiche():
  80. print(message)
  81. affiche()
  82. # NameError: 'affiche' is not defined
  83. C'est un mécanisme similaire aux :ref:`portées des variables <portées-des-variables>` vu précédemment.
  84. Deuxièment, la fonction `affiche()` à l'intérieur de `affiche_message()`
  85. a accès à l'argument `message` de la fonction `affiche_message`. On appelle
  86. ça une "closure".
  87. Fonctions retournant des fonctions
  88. ----------------------------------
  89. En réalité, on combine souvent les closures avec des fonctions qui
  90. retournent d'autres fonctions::
  91. def fabrique_fonction_qui_additionne(n):
  92. def fonction_résultat(x):
  93. return x + n
  94. return fonction_résultat
  95. additionne_2 = fabrique_fonction_qui_additionne(2)
  96. y = additionne_2(5)
  97. print(y)
  98. # Affiche: 7
  99. Un autre paradigme
  100. -------------------
  101. Le fait qu'on puisse traiter les fonctions comme n'importe quelle
  102. autre valeur (c'est-à-dire les assigner à des variables, les passer
  103. en argument et les retourner), est caractéristique des langages
  104. dits "fonctionnels". Python est donc **à la fois** un
  105. langages *impératif*, *objet* et *fonctionnel*. On dit que
  106. c'est un langage *multi-paradigme*.