En NSI, la programmation objet n’est au programme qu’en Terminale. Toutefois, on gagne \u00e0 l’aborder d\u00e8s la classe (!) de Premi\u00e8re, car elle simplifie certains apprentissages. Le langage choisi est Python 3, qui est pr\u00e9cis\u00e9ment un langage de programmation objet. Une progression est propos\u00e9e ici, bas\u00e9e sur la POO, pour le cours sur les donn\u00e9es structur\u00e9es (listes, tuples et dictionnaires en 1\u00e8re, piles, files, listes cha\u00een\u00e9es, arbres binaires en Tle).<\/p>\n\n\n\n
En fait, d\u00e8s la classe de 2nde (en SNT) il est possible d’aborder la POO, car certains objets connect\u00e9s se programment en Python, en appelant des m\u00e9thodes (de fait, les lutins de Scratch ressemblent beaucoup \u00e0 des objets). On programme de tels objets en micropython<\/a>, sur des cartes de type Arduino (ici, une ESP-32<\/a>).<\/p>\n\n\n\n Sachant que la LED de la carte est sur la broche 13, on la g\u00e8re logiciellement sous forme d’un objet La fonction Mais il y a aussi un n’allume pas la LED et pr\u00e9cise que Maintenant la LED est allum\u00e9e. Pour l’\u00e9teindre on peut faire Ce TP a \u00e9t\u00e9 fait en Premi\u00e8re NSI mais aussi en 2nde SNT. Bien entendu, il y a des \u00e9l\u00e8ves qui se demandent pourquoi ils n’arrivent pas \u00e0 allumer la LED \u00e0 moiti\u00e9 avec<\/p>\n\n\n\n On d\u00e9couvre exp\u00e9rimentalement que Cette fois-ci la LED est faiblement allum\u00e9e.<\/p>\n\n\n\n Les types au programme de Premi\u00e8re NSI sont<\/p>\n\n\n\n Pour v\u00e9rifier que ou, mieux, la fonction Pourquoi est-ce mieux que de chercher simplement le type de la variable ? Parce qu’avec cet affichage, on n’apprend pas que La pr\u00e9sence d’une m\u00e9thode Les m\u00e9thodes dont le nom commence, et finit, par un double underscore<\/em> (on les appelle m\u00e9thodes dunder<\/em>) sont celles que les tableaux (fac\u00e9tieusement appel\u00e9s listes en Python) h\u00e9ritent d’autres objets, et qui ne caract\u00e9risent pas les tableaux. Les autres par contre permettent de voir qu’on a affaire \u00e0 un objet auquel on peut ajouter quelque chose :<\/p>\n\n\n\n o\u00f9 l’on peut ins\u00e9rer quelque chose :<\/p>\n\n\n\n que l’on peut trier :<\/p>\n\n\n\n ou dont on peut retirer un \u00e9l\u00e9ment :<\/p>\n\n\n\n La fonction Distinguer des structures par le jeu des m\u00e9thodes qui les caract\u00e9risent.<\/p>\n<\/blockquote>\n\n\n\n Il s’agit d’une allusion au duck typing<\/a> cher \u00e0 Python. On verra plus bas qu’une bonne partie du cours de Terminale s’appuie sur ce principe. Mais avant cela, on peut aborder des m\u00e9thodes dunder qui clarifient beaucoup de choses sur les types construits vus en Premi\u00e8re.<\/p>\n\n\n\n Parmi les types au programme, seules les fonctions (et, en Terminale, les classes) sont appelables (callables<\/em>) c’est-\u00e0-dire que seules les fonctions poss\u00e8dent une m\u00e9thode Concr\u00e8tement cela signifie qu’on ne peut utiliser les parenth\u00e8ses qu’avec des fonctions. Si on essaye avec un tableau on a ceci :<\/p>\n\n\n\n Pour acc\u00e9der \u00e0 un \u00e9l\u00e9ment d’un des types construits (\u00e0 partir d’un index ou d’une cl\u00e9) on doit utiliser les crochets :<\/p>\n\n\n\n La possibilit\u00e9 de lire un \u00e9l\u00e9ment d’une collection (et donc de parcourir la collection) est la cons\u00e9quence de la pr\u00e9sence d’une m\u00e9thode Les cha\u00eenes de caract\u00e8res et les types construits sont suscriptables<\/em> : on peut utiliser la notation des crochets pour examiner l’int\u00e9rieur de ces objets. Les fonctions par contre ne sont pas suscriptables :<\/p>\n\n\n\n En fait, pour les tableaux, il est \u00e9galement possible d’utiliser la notation des crochets pour modifier un des \u00e9l\u00e9ments du tableau :<\/p>\n\n\n\n En fait les tableaux ne sont pas seulement suscriptables, ils sont \u00e9galement mutables<\/em>. Cela est d\u00fb \u00e0 leur m\u00e9thode En fait, seuls les tableaux et les dictionnaires sont mutables. Les autres types (y compris les types de base) sont immuables<\/em>. Cela n’a donc pas de sens de donner une m\u00e9thode On verra plus bas comment simuler en Python un dictionnaire par une table de hashage, mais pour l’instant, il est bon de savoir que les cl\u00e9s des dictionnaires doivent \u00eatre hashables, et qu’on ne peut donc pas utiliser de tableaux ni de dictionnaires comme cl\u00e9s de dictionnaires : les cl\u00e9s doivent \u00eatre immuables pour \u00eatre hashables.<\/p>\n\n\n\n La mutabilit\u00e9 des tableaux de Python pose probl\u00e8me :<\/p>\n\n\n\n En voulant modifier La m\u00e9thode copy() n’\u00e9tant pas au programme de NSI, on peut lui pr\u00e9f\u00e9rer la liste en compr\u00e9hension (qui, elle, est au programme) :<\/p>\n\n\n\n En Terminale (et parfois au bac) les \u00e9l\u00e8ves ont parfois \u00e0 cr\u00e9er leurs propres objets, avec l’instruction Les graphes sont plut\u00f4t compliqu\u00e9s \u00e0 programmer objet, en raison du nombre de m\u00e9thodes dont on a besoin. D’ailleurs des modules Python sp\u00e9cialis\u00e9s (graphviz<\/a>, networkx<\/a>) existent d\u00e9j\u00e0. Cependant, on peut mod\u00e9liser (voir exercice 3 du sujet jour 2 centres \u00e9trangers 2025) un sommet d’un graphe orient\u00e9 avec<\/p>\n\n\n\n Un graphe est alors une liste de sommets.<\/p>\n\n\n\n Les arbres \u00e9tant des graphes particuliers (connexes sans cycle) peuvent \u00eatre mod\u00e9lis\u00e9s de la m\u00eame mani\u00e8re que les autres graphes, avec une liste d’enfants, mais dans un arbre, chaque n\u0153ud n’a qu’un parent ce qui permet cette mod\u00e9lisation :<\/p>\n\n\n\n le seul parent d’un n\u0153ud \u00e9tant un n\u0153ud, sauf pour la racine qui n’a pas de parent (d’o\u00f9 le Un arbre binaire a une racine et deux sous-arbres (gauche et droit) qui sont chacun soit et pour un arbre binaire de recherche, on ajoute une m\u00e9thode de recherche (c’est le but) et d’insertion (de mani\u00e8re que la structure d’arbre binaire de recherche soit un invariant) :<\/p>\n\n\n\n Plus simples que les arbres binaires, les listes cha\u00een\u00e9es en h\u00e9ritent : selon le mod\u00e8le de Newell et Shaw (1957) une liste cha\u00een\u00e9e est un arbre binaire dans lequel chaque n\u0153ud n’a qu’un enfant droit :<\/p>\n\n\n\n On a essentiellement red\u00e9fini le vocabulaire, en nommant final ce qui s’appelait feuille et suivant ce qui s’appelait enfant droit.<\/p>\n\n\n\n On peut aussi utiliser la surcharge de m\u00e9thodes pour rendre la classe plus pythonienne :<\/p>\n\n\n\n L’utilisation de m\u00e9thodes dunder<\/em> permet alors de faire ce genre de session :<\/p>\n\n\n\n Une pile est un objet dot\u00e9 de m\u00e9thodes d’empilement et de d\u00e9pilement, ainsi qu’un test de vacuit\u00e9. La m\u00e9thode permettant de cr\u00e9er une pile vide n’est autre que le La classe File peut se d\u00e9finir d’une mani\u00e8re similaire \u00e0 la classe Pile :<\/p>\n\n\n\n ou alors \u00e0 l’aide de deux piles (au programme de Terminale NSI) :<\/p>\n\n\n\n La construction des dictionnaires n’est pas vraiment au programme, tout au plus peut-on y lire :<\/p>\n\n\n\n Distinguer la recherche d\u2019une valeur dans une liste et dans un dictionnaire.<\/p>\n<\/blockquote>\n\n\n\n Cependant, avec des \u00e9l\u00e8ves qui ont d\u00e9j\u00e0 quelque exp\u00e9rience en POO, on peut envisager de simuler les dictionnaires (y compris leur affichage) en Python :<\/p>\n\n\n\n Ce dictionnaire light de Python s’utilise comme le vrai dictionnaire :<\/p>\n\n\n\n Afin de voir la proportion de POO dans le cours, voici celui-ci (sur les trois ann\u00e9es du lyc\u00e9e) :<\/p>\n\n\n\n Cours de SNT (2nde) :<\/p>\n\n\n\nPin<\/code> (broche) que l’on importe du module machine<\/code>, et qu’on cr\u00e9e logiciellement ainsi :<\/p>\n\n\n\n>>> from machine import Pin\n>>> led = Pin(13,Pin.OUT)\n>>> dir(led)\n['__class__', 'value', 'DRIVE_0', 'DRIVE_1', 'DRIVE_2', 'DRIVE_3', 'IN', 'IRQ_FALLING', 'IRQ_RISING', 'OPEN_DRAIN', 'OUT', 'PULL_DOWN', 'PULL_UP', 'WAKE_HIGH', 'WAKE_LOW', 'board', 'init', 'irq', 'off', 'on']\n<\/code><\/pre>\n\n\n\ndir<\/code> donne la liste des m\u00e9thodes de la broche, et on constate qu’il y a plusieurs constantes (dont le nom s’\u00e9crit en majuscules ; si seule la premi\u00e8re lettre est en majuscule, on convient qu’il s’agit d’un objet), parmi lesquelles OUT<\/code>, qui est un entier : <\/p>\n\n\n\n>>> led.OUT\n3<\/code><\/pre>\n\n\n\non<\/code> dont on se doute qu’il sert \u00e0 allumer la LED, seulement<\/p>\n\n\n\n>>> led.on\n<bound_method><\/code><\/pre>\n\n\n\non<\/code> est une m\u00e9thode (une fonction qui n’appartient qu’\u00e0 la LED). Pour allumer la LED on doit appeler cette m\u00e9thode (en pr\u00e9cisant \u00e0 qui on s’adresse, en pr\u00e9c\u00e9dant l’appel de la m\u00e9thode du nom de la variable) avec on()<\/code> :<\/p>\n\n\n\n>>> led.on()<\/code><\/pre>\n\n\n\nled.off()<\/code> mais aussi modifier sa valeur; \u00e9gale \u00e0 1 lorsqu’elle est allum\u00e9e et \u00e0 0 lorsqu’elle est \u00e9teinte :<\/p>\n\n\n\n>>> led.value()\n1\n>>> led.value(0)\n>>> led.value()\n0<\/code><\/pre>\n\n\n\n>>> led.value(0.5)\n>>> led.value(0.000001)\n>>> led.value()\n1<\/code><\/pre>\n\n\n\nPin(13)<\/code> est une sortie num\u00e9rique (elle ne peut prendre que les valeurs 0 ou 1, toute valeur non nulle \u00e9tant assimil\u00e9e \u00e0 1). Pour simuler l’allumage graduel de la LED, il faut moduler en largeur d’impulsions cette sortie num\u00e9rique, \u00e0 l’aide d’un objet PWM (Pulse Width Modulation) :<\/p>\n\n\n\n>>> from machine import PWM\n>>> p = PWM(led)\n>>> dir(p)\n['__class__', 'deinit', 'duty', 'duty_ns', 'duty_u16', 'freq', 'init']\n>>> p.duty()\n512\n>>> p.duty(8)<\/code><\/pre>\n\n\n\nCours de Premi\u00e8re NSI bas\u00e9 sur la POO<\/h2>\n\n\n\n
\n
bool<\/code>, entiers int<\/code>, flottants float<\/code> et cha\u00eenes de caract\u00e8res str<\/code>) y compris les fonctions,<\/li>\n\n\n\nlist<\/code>, n-uplets tuple<\/code> et dictionnaires dict<\/code>).<\/li>\n<\/ul>\n\n\n\n[1,2,3]<\/code> est un tableau, on peut lui appliquer la fonction type<\/code> :<\/p>\n\n\n\n>>> tab = [1,2,3]\n>>> type(tab)\n<class 'list'><\/code><\/pre>\n\n\n\ndir<\/code> :<\/p>\n\n\n\n>>> dir(tab)\n['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']<\/code><\/pre>\n\n\n\ntab<\/code> est un tableau, mais qu’est-ce qu’un tableau, ou plut\u00f4t qu’est-ce qu’on peut faire avec. Par exemple la pr\u00e9sence d’une m\u00e9thode __add__<\/code> permet d’additionner des tableaux :<\/p>\n\n\n\n>>> tab + [1,2]\n[1, 2, 3, 1, 2]<\/code><\/pre>\n\n\n\n__len__<\/code> permet d’utiliser la fonction len<\/code> (les tableaux ont donc une longueur) :<\/p>\n\n\n\n>>> len(tab)\n3<\/code><\/pre>\n\n\n\n>>> tab.append(5)\n>>> tab\n[1, 2, 3, 5]<\/code><\/pre>\n\n\n\n>>> tab.insert(2,8)\n>>> tab\n[1, 2, 8, 3, 5]<\/code><\/pre>\n\n\n\n>>> tab.sort()\n>>> tab\n[1, 2, 3, 5, 8]<\/code><\/pre>\n\n\n\n>>> tab.pop()\n8\n>>> tab\n[1, 2, 3, 5]<\/code><\/pre>\n\n\n\ndir<\/code> permet (en se concentrant sur les m\u00e9thodes non dunder<\/em>) d’obtenir un r\u00e9sum\u00e9 du cours (ici, sur les tableaux de Python) et, par l\u00e0, de donner plus d’autonomie aux \u00e9l\u00e8ves en pratique Python. Le programme de Terminale stipule que<\/p>\n\n\n\n\n
Mutabilit\u00e9, immuabilit\u00e9 et aliasing<\/h2>\n\n\n\n
__call__<\/code> :<\/p>\n\n\n\n>>> [o for o in [str,list,tuple,dict] if '__call__' in dir(o)]\n[]<\/code><\/pre>\n\n\n\n>>> tab(2)\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: 'list' object is not callable<\/code><\/pre>\n\n\n\n>>> tab[2]\n3<\/code><\/pre>\n\n\n\n__getitem__<\/code> :<\/p>\n\n\n\n>>> [o for o in [str,list,tuple,dict] if '__getitem__' in dir(o)]\n[<class 'str'>, <class 'list'>, <class 'tuple'>, <class 'dict'>]<\/code><\/pre>\n\n\n\n>>> from math import *\n>>> sin[pi\/2]\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: 'builtin_function_or_method' object is not subscriptable\n>>> sin(pi\/2)\n1.0<\/code><\/pre>\n\n\n\n>>> tab[2] = 13\n>>> tab\n[1, 2, 13, 5]<\/code><\/pre>\n\n\n\n__setitem__<\/code>, ce qui fait qu’on peut savoir quels sont les types mutables au programme de NSI :<\/p>\n\n\n\n>>> [o for o in [str,list,tuple,dict] if '__setitem__' in dir(o)]\n[<class 'list'>, <class 'dict'>]<\/code><\/pre>\n\n\n\nappend<\/code> ou pop<\/code> \u00e0 un tuple. L’int\u00e9r\u00eat des objets immuables est qu’on peut les hasher<\/em> :<\/p>\n\n\n\n>>> hash(tab)\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: unhashable type: 'list'<\/code><\/pre>\n\n\n\n>>> tab1 = [1,2,3]\n>>> tab2 = tab1\n>>> tab1\n[1, 2, 3]\n>>> tab2\n[1, 2, 3]\n>>> tab2[1] = 8\n>>> tab2\n[1, 8, 3]\n>>> tab1\n[1, 8, 3]<\/code><\/pre>\n\n\n\ntab2<\/code>, on a aussi modifi\u00e9 tab1<\/code>. Une solution consisterait \u00e0 travailler, non sur tab1<\/code>, mais sur une copie d’icelui :<\/p>\n\n\n\n>>> tab1 = [1,2,3]\n>>> tab2 = tab1.copy()\n>>> tab2[1] = 8\n>>> tab1\n[1, 2, 3]<\/code><\/pre>\n\n\n\n>>> tab1 = [1,2,3]\n>>> tab2 = [x for x in tab1]\n>>> tab2[1] = 8\n>>> tab1\n[1, 2, 3]<\/code><\/pre>\n\n\n\nCours de Terminale NSI bas\u00e9 sur la POO<\/h2>\n\n\n\n
class<\/code>. Un bon exemple d’utilisation de cette construction est constitu\u00e9 des structures de donn\u00e9es qui sont au programme, \u00e0 savoir les piles, les files, les listes cha\u00een\u00e9es, les arbres binaires, les arbres et les graphes. Cela est tr\u00e8s proche de l’approche du livre de Christine Froidevaux<\/a> et al<\/em>, bas\u00e9 sur une axiomatique des types abstraits de donn\u00e9s. <\/p>\n\n\n\nLes graphes<\/h3>\n\n\n\n
class Sommet:\n def __init__(self,valeur):\n self.valeur = valeur\n self.enfants = []\n def ajouter_enfant(self,sommet):\n self.enfants.append(sommet)<\/code><\/pre>\n\n\n\nclass Noeud:\n def __init__(self,valeur):\n self.valeur = valeur\n self.parent = None<\/code><\/pre>\n\n\n\nNone<\/code>). <\/p>\n\n\n\nLes arbres binaires<\/h3>\n\n\n\n
None<\/code>, soit un arbre binaire : <\/p>\n\n\n\nclass Arbre:\n def __init__(self,nom):\n self.label = nom\n self.G = None\n self.D = None\n def est_une_feuille(self):\n return self.G is None and self.D is None\n def greffe_gauche(self,greffe):\n self.G = greffe\n def greffe_droite(self,greffe):\n self.D = greffe <\/code><\/pre>\n\n\n\n def dedans(self,clef):\n if self.label==clef:\n return True\n elif self.label>clef and self.G is not None:\n return self.G.dedans(clef)\n elif self.label<clef and self.D is not None:\n return self.D.dedans(clef)\n else:\n return False \n\n def ajouter(self,clef):\n assert not self.dedans(clef)\n if self.label>clef:\n if self.G is None:\n self.greffe_gauche(BST(clef))\n else:\n self.G.ajouter(clef)\n elif self.label<clef:\n if self.D is None:\n self.greffe_droite(BST(clef))\n else:\n self.D.ajouter(clef)\n else:\n self=BST(clef) <\/code><\/pre>\n\n\n\nListes cha\u00een\u00e9es<\/h3>\n\n\n\n
class Liste:\n def __init__(self,label):\n self.label = label\n self.suivant = None\n def est_final(self):\n return self.suivant is None\n def suite(self):\n return self.suivant\n def ajout(self,elt):\n if self.est_final():\n self.suivant = Liste(elt)\n else:\n self.suivant.ajout(elt)<\/code><\/pre>\n\n\n\nclass Liste:\n def __init__(self,label):\n self.label = label\n self.suivant = None\n def est_final(self):\n return self.suivant is None\n def __repr__(self):\n if self.est_final():\n return str(self.label)\n else:\n return str(self.label)+'\u2192'+self.suivant.__repr__()\n def suite(self):\n return self.suivant\n def ajout(self,elt):\n if self.est_final():\n self.suivant = Liste(elt)\n else:\n self.suite().ajout(elt)\n def __len__(self):\n if self.est_final():\n return 1\n else:\n return 1 + len(self.suite())\n def __contains__(self,elt):\n if self.est_final():\n return self.label==elt\n else:\n return self.label==elt or elt in self.suite()<\/code><\/pre>\n\n\n\n>>> a = Liste(3)\n>>> a.ajout(1)\n>>> a.ajout(4)\n>>> a\n3\u21921\u21924\n>>> len(a)\n3\n>>> 1 in a\nTrue<\/code><\/pre>\n\n\n\nPiles<\/h3>\n\n\n\n
__init__<\/code> de Python :<\/p>\n\n\n\nclass Pile:\n def __init__(self):\n self.tab = []\n def est_vide(self):\n return self.tab == []\n def empiler(self,elt):\n self.tab.append(elt)\n def depiler(self):\n return self.tab.pop()<\/code><\/pre>\n\n\n\nFiles<\/h3>\n\n\n\n
class File:\n def __init__(self):\n self.tab = []\n def est_vide(self):\n return self.tab == []\n def enfiler(self,elt):\n self.tab.append(elt)\n def defiler(self):\n return self.tab.pop(0)<\/code><\/pre>\n\n\n\nclass File:\n def __init__(self):\n self.pile1 = Pile()\n self.pile2 = Pile()\n def est_vide(self):\n return self.pile1.est_vide() and self.pile2.est_vide()\n def flush(self):\n while not self.pile1.est_vide():\n self.pile2.empiler(self.pile1.depiler())\n def enfiler(self,elt):\n self.pile1.empiler(elt)\n def defiler(self):\n if self.pile2.est_vide():\n self.flush()\n return self.pile2.depiler()<\/code><\/pre>\n\n\n\nDictionnaires<\/h3>\n\n\n\n
\n
def h(o):\n return hash(o) % 256\n\nclass Dictionnaire:\n def __init__(self):\n self.clefs = [None]*256\n self.valeurs = [None]*256\n def __setitem__(self,clef,valeur):\n self.clefs[h(clef)] = clef\n self.valeurs[h(clef)] = valeur\n def __getitem__(self,clef):\n return self.valeurs[h(clef)]\n def __repr__(self):\n s = '{'\n for i in range(len(self.clefs)):\n if self.clefs[i] is not None:\n s += str(self.clefs[i])\n s += ':'\n s += str(self.valeurs[i])\n s += ', '\n return s + '}'<\/code><\/pre>\n\n\n\n>>> dico = Dictionnaire()\n>>> dico[2] = 3\n>>> dico[5] = 8\n>>> dico\n{2:3, 5:8, }<\/code><\/pre>\n\n\n\nLe cours complet en pdf<\/h2>\n\n\n\n