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.
 
 
 
 
 
 

143 lines
3.2 KiB

  1. Objets
  2. ======
  3. En fait, *tout ce qu'on manipule en Python* est un objet. Et tous les objets sont
  4. toujours des instances d'une classe - on peut accéder à la classe qui a servi
  5. à instancier un objet avec la fonction ``type``, par exemple::
  6. class MaClasse:
  7. pass
  8. mon_instance = MaClasse()
  9. print(type(mon_instance))
  10. # Affiche:
  11. # <class '__main__.MaClasse'>
  12. Mais aussi::
  13. print(type(2))
  14. # affiche: int
  15. print(type("bonjour"))
  16. # affiche: str
  17. Donc en Python, les entiers sont des instances de la classe ``int``, et les strings des instances de la
  18. classe ``str``.
  19. Ainsi, vous pouvez voir l'expression ``x = str(y)`` de deux façons:
  20. * Soit on appelle la fonction native ``str`` pour convertir ``y`` en string
  21. * Soit on crée une nouvelle instance de la classe ``str`` en appelant le constructeur
  22. de la classe ``str`` avec ``y`` en argument.
  23. Notez que ça ne s'arrète pas là::
  24. def ma_fonction():
  25. pass
  26. print(type(ma_fonction))
  27. # affiche: function
  28. class MaClasse:
  29. def ma_méthode(self):
  30. pass
  31. mon_instance = MaClasse()
  32. print(type(mon_instance.ma_méthode))
  33. # affiche: method
  34. import sys
  35. print(type(sys))
  36. # affiche: module
  37. Et même::
  38. print(type(MaClasse))
  39. # affiche: type
  40. print(type(type))
  41. # affiche: type
  42. Et oui, les classes elles-mêmes sont des instances de classe! (la classe ``type``)
  43. Du coup en Python, le terme 'objet' désigne *toujours* une instance de classe - même
  44. ``None`` est une instance d'une classe (elle s'appelle ``NoneType``).
  45. Ordre de résolution
  46. --------------------
  47. Il est temps de revenir sur l'évaluation des expressions impliquant des
  48. attributs.
  49. On a vu trois systèmes différents:
  50. Appeler une fonction définie dans un module::
  51. import mon_module
  52. mon_module.ma_fonction()
  53. Appeler une méthode d'instance définie dans une classe::
  54. mon_instance = MaClasse()
  55. mon_instance.ma_méthode()
  56. Appeler une méthode de classe définie dans une classe::
  57. MaClasse.ma_méthod_de_classe()
  58. D'après ce qu'on a vu dans la section précédente, on sait maintenant que
  59. dans tous les cas, à gauche du point se situe un objet, et que tous
  60. les objets sont des instances d'une classe (appelé le "type" de l'objet).
  61. Pour évaluer l'expression ``mon_objet.mon_attribut``, où `mon_objet`` est une
  62. instance de ``mon_type``, Python cherche toujours l'attribut dans deux endroits:
  63. * D'abord en tant qu'attribut de l'instance ``mon_objet``
  64. * Ensuite, en tant qu'attribut de la classe ``mon_type``
  65. La recherche se poursuit ainsi en suivant toutes les classe parentes de
  66. ``mon_type``.
  67. On peut voir ce mécanisme en action dans le code suivant::
  68. class A:
  69. def f1(self):
  70. print("f1 dans A")
  71. def f2(self):
  72. print("f2")
  73. class B(A):
  74. @classmethod
  75. def f3(cls):
  76. print("f3")
  77. def f1(self):
  78. print("f1 dans B")
  79. b = B()
  80. b.f1()
  81. b.f3()
  82. b.f2()
  83. # affiche:
  84. # f1 dans B
  85. # f3
  86. # f2
  87. Conclusion
  88. ------------
  89. Maintenant vous devriez comprendre pourquoi on dit parfois qu'en
  90. Python, **tout est objet**.
  91. Dans un prochain chapitre, on expliquera pourquoi en plus de cela
  92. on peut dire qu'en Python, **tout est dictionnaire**.