Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
Den här utvecklingskatalogen är arkiverad. Du kan se filer och klona katalogen, men inte öppna ärenden eller genomföra push- eller pull-förfrågningar.
 
 
 
 
 
 

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