# data[].attributes.body
Yann Salmon

# data[].attributes.attachment_link.readable_text
Le document d'accompagnement pour l'algorithmique et la programmation en seconde mentionne page 13 :

Un ordinateur ne travaille pas avec des nombres réels, mais avec des flottants, c'est-à-dire un sous-ensemble des nombres décimaux dont la précision est limitée par des contraintes liées au codage en mémoire.

C'est ainsi qu'en Python, le test d'égalité 3+10**(-16)==3 s'évalue en True alors que le test 3+10**(-15)==3 s'évalue en False. On retiendra qu'il faut éviter de tester l'égalité entre deux flottants, et préférer la recherche d'une précision donnée. En revanche, bien sûr, il n'y a aucun problème à comparer deux nombres entiers.

C'est tout à fait exact et le programme de seconde ne demande pas d'enseigner les subtilités des flottants aux élèves. Cependant, au cours de leurs manipulations, les élèves peuvent obtenir des résultats qui semblent aberrants si on assimile les flottants aux réels, comme dans l'exemple cité. Également, on constate que 1.1 + 1.1 donne 2.2 mais que 1.1 + 1.1 + 1.1 donne 3.3000000000000003. Il peut être utile au professeur d'en savoir un peu plus afin de pouvoir en dire suffisamment aux élèves pour que l'informatique et les résultats qu'elle donne n'apparaissent pas comme quelque chose d'ésotérique. Cela permet aussi de comprendre pourquoi certaines façons de faire qu'on pouvait être contraint d'utiliser avec certaines calculatrices limitées sont à bannir.

Dans cette note, je donne des éléments concernant le comportement des flottants, ce qui m'amènera à parler un peu de la façon dont ils sont représentés dans la mémoire de l'ordinateur. Je n'aborderai pas les entiers. Bien qu'il y a des choses à dire sur les entiers en machine, en Python les entiers proposés se comportent exactement comme les entiers mathématiques : tout va bien.

Le fonctionnement interne : les flottants

Nombres dyadiques

Nul n'en sera surpris, les flottants sont représentés en mémoire en base 2. Seuls sont donc éventuellement représentables les nombres qui admettent une écriture à virgule en base deux : on les appelle les nombres dyadiques ; ils sont à la base 2 ce que les décimaux sont à la base 10. Un réel est dyadique si et seulement s'il admet une écriture sous la forme \(\frac A{2^k}\) avec \(A\) et \(k\) des entiers.

Ainsi, tout nombre dyadique est décimal, mais la réciproque est fausse : 0.1, qu'on est tenté d'utiliser comme pas dans un algorithme, est un mauvais choix car il n'est pas dyadique : lorsqu'on écrit 0.1 en Python, on ne manipule pas 0.1 mais le flottant le plus proche de cette quantité.

Mais bien sûr tous les nombres dyadiques ne sont pas représentables comme flottants. Pour écrire un flottant, on se donne un certain nombre de chiffres binaires (bits), souvent 64 sur les machines modernes : on pourra donc représenter au maximum \(2^{64}\) nombres dyadiques. Cela signifie qu'on ne pourra pas représenter les dyadiques dont l'écriture comprend trop de chiffres binaires : on sera obligé d'arrondir.

Reste à décider quels dyadiques on représente. On doit choisir un intervalle en dehors duquel aucun nombre ne sera représentable. Mais on doit aussi choisir une résolution, un pas d'un représentable au représentable suivant. Une possibilité est de fixer un pas uniforme pour tout l'intervalle représentable : c'est le système de la virgule fixe, qui revient en fait à compter avec des entiers (bornés) avec une unité plus petite. C'est pratique dans les calculs monétaires par exemple : on sait qu'on veut partout une précision au millième d'euro, donc on compte en millièmes d'euros.

Les flottants

Au contraire, le système de la virgule flottante établit un pas qui dépend de l'ordre de grandeur du nombre à représenter, ce qui permet de conserver le même nombre de chiffres significatifs partout.

Tout réel non nul peut s'écrire de façon unique en écriture scientifique en base 2, c'est-à-dire \((-1)^s\times m\times 2^e\) avec \(s\in\{0,1\}\), \(m\in[1,2[\) et \(e\in\mathbb Z\). Ces nombres sont appelés signe, mantisse et exposant du réel. On utilise 1 bit pour représenter le signe et un nombre conventionnel de bits pour la mantisse, en pratique 52, et pour l'exposant, en pratique 11. Un flottant est constitué en mémoire par la mise bout-à-bout du bit de signe, des 11 bits qui représentent (astucieusement) l'exposant et des 52 bits qui représentent (tout aussi astucieusement) la mantisse.

On dispose donc sur presque tout l'intervalle \([-2^{2^{10}}, 2^{2^{10}}]\) d'une précision à 53 chiffres binaires significatifs. Pourquoi 53 alors qu'on n'a que 52 bits pour la mantisse ? Parce que la mantisse étant dans l'intervalle \([1, 2[\), elle commence forcément par le chiffre 1, et on n'a donc pas besoin de le noter en mémoire, ce qui fait gagner un chiffre.

Conséquences pratiques

Quand on arrive à l'ordre de grandeur \(2^{53}\), l'intervalle qui sépare un flottant du flottant suivant devient plus grand que 1 : il y a des entiers qui ne sont pas représentables (tous les entiers impairs, puis tous entiers pairs qui ne sont pas des multiples de 4, etc.). Voilà pourquoi on ne doit pas tester la divisibilité d'un entier a par un entier b en faisant a/b == a//b (ou pire a/b == int(a/b)) : outre que ça fait calculer deux divisions dont une en flottants, cette dernière n'est plus assez précise dès l'ordre de grandeur \(2^{53}\). Le test proposé conduit à considérer \(2^{53} + 1\) comme un entier pair. La division entière avec // donne bien sûr \(2^{52}\) et la division en flottants se déroule comme suit : quand on fait (2**53+1)/2, Python convertit les deux opérandes en flottants car / est l'opérateur de division flottante ; mais pour 2**53+1, cela donne 2.0**53 dont la division par 2.0 donne 2.0**52, qui est converti en 2**52 pour la comparaison avec l'entier trouvé de l'autre côté du == (à moins que ce ne soit l'autre qui soit converti en flottant, je ne sais plus).

Heureusement, Python propose l'opérateur modulo qui permet de faire ce test avec a % b == 0 ce qui est exact, plus rapide et plus élégant.

Il y a d'autres conséquences, notamment le fait que l'addition n'est pas associative sur les flottants (elle est en revanche commutative). Plus généralement, on subit des pertes de précision lorsqu'on ajoute ou soustrait des flottants dont les ordres de grandeurs sont très différents : pour le faire, il est nécessaire d'exprimer temporairement les deux flottants avec l'exposant le plus fort pour pouvoir traiter bit à bit les mantisses ainsi alignées. Mais en raison de la taille limitée de ces dernières, on perd au passage les chiffres les moins significatifs de l'opérande le plus petit. 2.0**53 + 1.0 en est un cas extrême : le petit opérande est si petit devant l'autre qu'il disparait complètement lors de cet alignement.

Représentation pour l'affichage

Tout ceci explique pourquoi il n'est pas étonnant que 1.1+1.1+1.1 ne donne pas 3.3 : on manipule des quantités qui ne sont pas ce qu'on croit. Mais pourquoi le résultat 3.3000000000000003 apparait-il soudain alors qu'on avait un gentil 2.2 quand on évaluait 1.1+1.1 ?

C'est que les entrées et sorties de la console Python sont en base 10 : après avoir calculé avec les flottants, Python doit produire une écriture décimale correspondant au résultat. Compte tenu de l'existence d'un écart entre chaque flottant et le suivant, il y a en fait une infinité d'écritures décimales qui conviendraient. Python choisit la plus courte écriture décimale ayant la propriété suivante : si on copie-colle ce résultat affiché comme nouvelle entrée, le flottant qui sera ainsi lu sera le même.

En résumé 1.1 ne vaut pas 1.1 (mais un peu plus), 1.1+1.1 ne vaut pas 2.2 mais un flottant un peu plus grand ; cependant si on saisit 2.2, on retombe sur ce flottant. Tandis que 3.3 s'évalue en un flottant qui est différent de celui obtenu en faisant 1.1+1.1+1.1 (le premier est un peu en dessous de 3.3, le deuxième un peu au dessus).

On peut connaitre la valeur précise qu'on manipule en écrivant un nombre à virgule avec le module decimal de Python :

Et les calculatrices ?

Il existe d'autres façons de manipuler des pseudo-réels en mémoire, notamment le " décimal codé binaire ", qui consiste, en gros, à écrire dans la mémoire les nombres en base 10 comme on le ferait en math. On obtient alors un comportement plus proche de ce qui se passe en math. En particulier on peut manipuler 1.1.

Le cout de cette représentation est double : on consomme plus de mémoire et on calcule plus lentement, parce qu'on ne bénéficie pas des circuits de calcul optimisés du processeur qui travaillent avec les flottants.

Conclusion

Encore une fois, on ne va pas enseigner tout cela en seconde. Mais j'espère avoir fourni quelques éléments qui pourront aider à répondre à des questions d'élèves curieux.

Pour aller plus loin sur l'aspect technique, on peut lire l'article Virgule flottante de Wikipédia par exemple.

Guillaume Connan propose un article expliquant plus conceptuellement comment on peut avoir des garanties sur les calculs en flottants : le lemme de Sterbenz (1973) assure que pour deux flottants tels que \(\frac x2\leq y\leq 2\,x\), la différence \(x-y\) est calculée sans erreur ; plus généralement, l'erreur commise lors de l'addition de deux flottants est elle-même un flottant, dont on peut récupérer exactement la valeur ! Cela permet de concevoir des algorithmes (Dekker-Kahan notamment) d'addition qui minimisent l'accumulation de ces erreurs.

Ces limitations intrinsèques posent des difficultés dans les algorithmes numériques. Le pivot de Gauss, notamment, est numériquement instable Pour les algorithmes itératifs (méthode d'Euler, etc.), choisir un pas plus petit n'améliore pas toujours le résultat ; on peut estimer le pas \(h\) optimal pour un problème et une méthode données ; voir (si on le trouve car il est épuisé) l'excellent Analyse numérique et Équations différentielles de Jean-Pierre Demailly, dont je ne résiste pas au plaisir de citer l'introduction :

Il existe des logiciels libres spécialisés dans le calcul numérique qui implémentent les principaux algorithmes utiles sous forme de librairies toutes prêtes - Scilab est l'un des plus connus [les bibliothèques numpy et scipy de Python le sont désormais aussi] - mais d'un point de vue pédagogique et dans un premier temps au moins, il est bien plus formateur pour les étudiants de mettre vraiment "la main dans le cambouis" en programmant eux-mêmes les algorithmes. Nous ne citerons pas d'environnements ni de logiciels propriétaires équivalents, parce que ces logiciels dont le fonctionnement intime est inaccessible à l'utilisateur sont contraires à notre éthique scientifique ou éducative, et nous ne souhaitons donc pas en encourager l'usage.

# data[].attributes.attachment_link.title
Informatique en seconde : que savoir sur les flottants ?

# data[].attributes.attachment_link.description
Le document d'accompagnement pour l'algorithmique et la programmation en seconde mentionne page 13~: Un ordinateur ne travaille pas avec des nombres réels, mais avec des flottants, c'est-à-dire un sous-ensemble des nombres décimaux dont la précision est limitée par des contraintes liées au c...

# data[].attributes.body
ac-Rouen

# data[].attributes.attachment_link.description
Aménagements du programme de seconde - Rentrée 2017 Le programme de Seconde, pour la rentrée 2017, fait l'objet de formations disciplinaires réparties sur une journée en ce qui concerne les mathématiques dans l'Académie de Rouen. L'ensemble des professeurs de mathématiques exerçant en lycée dans (...)

# data[].attributes.body
Auteur : Thomas Lenne

# data[].attributes.body
Différents parcours.

# data[].attributes.body
Une mine de problèmes à résoudre par de la programmation.

# data[].attributes.body
Par J-M. Ferrard. Des solutions aux problèmes de project Euler

# data[].attributes.attachment_link.readable_text
Petites références Python et Numpy

J'ai écrit les documents suivants, que je mets à la disposition de tous.
Dans la perspective des nouveaux programmes d'informatique pour tous, ils pourront être utiles aussi bien aux élèves qu'aux enseignants.
Les conditions d'utilisation sont celles de la licence Creative Commons

Si vous téléchargez plusieurs fois le même fichier, le compteur n'est incrémenté qu'une fois.

1. Un mémento du langage Python (environ 70 pages)
Une petite référence Python

2. Un mémento de la bibliothèque Numpy (environ 60 pages)
Une petite référence Numpy

Quelques exercices du "Project Euler"

Le Project Euler est situé à l'adresse suivante: http://projecteuler.net.

Il propose aux apprentis programmeurs, mais aussi aux programmeurs chevronnés, la résolution d'une très grande quantité de problèmes (576 à ce jour, et un nouveau chaque semaine). Si les tous premiers énoncés sont assez faciles à résoudre, le niveau d'exigence s'élève rapidement. Pour un problème donné, on peut soumettre sa propre solution sur le site: si celle-ci est correcte, on accède aux pages correspondantes du forum et on peut comparer ses propres solutions à celles des autres utilisateurs du site (c'est là qu'on se rend compte qu'on a des progrès à faire!)

On peut toujours tricher et consulter un autre site qui livre pour rien la quasi-totalité des solutions des problèmes du Project Euler, et passer aux yeux des autres pour un génie de la programmation, mais pas à ses propres yeux (et de toutes façons, les responsables de Project Euler savent très bien repérer et bannir les tricheurs).

À ce jour, j'ai dû résoudre une soixantaine d'exercices du Project Euler. Vous trouverez ici mes solutions à quelques-uns des tous premiers énoncés (réponses écrites en Python). Anyway, si vous avez le temps pour ça, je vous engage à essayer de répondre par vous-même aux problèmes posés avant de consulter les solutions.

Euler 001: somme des entiers de [0,N[ divisibles par 3 ou par 5
Euler 002: somme des nombres de Fibonacci pairs et inférieurs à N
Euler 003: fonction donnant le plus grand facteur premier de N
Euler 004: palindrome max produit de deux entiers à trois chiffres
Euler 005: plus petit entier >0 et divisible par les entiers de 1 à N
Euler 006: fonction calculant \bigl(\sum_{k=1}^{n}k\bigr)^{2}-\sum_{k=1}^{n}k^{2}
Euler 007: fonction renvoyant le n-ième nombre premier
Euler 008: produit max de 5 chiffres consécutifs de n (1000 chiffres)
Euler 009: triplets rectangulaires de somme donnée
Euler 010: somme des entiers premiers strictement inférieurs à N
Euler 011: produit max de 4 nombres adjacents d'une grille 20\times 20
Euler 012: plus petit nombre triangulaire ayant plus de N diviseurs
Euler 013: dix premiers chiffres de la somme de cent nombres
Euler 014: plus longue suite avant retour à 1 dans suite de Collatz
Euler 015: nombre de déplacements dans une grille
Euler 016: somme des chiffres de la représentation décimale de 2^{N}
Euler 017: combien de lettres pour les nombres de 1 à 1000 en anglais
Euler 018: somme max des parcours d'une grille triangulaire
Euler 019: combien de 1ers du mois sont un dimanche, de 1901 à 2001
Euler 020: somme des chiffres de l'écriture décimale de l'entier N!
Euler 021: somme des paires d'amiables strictement inférieurs à N
Euler 022: total des scores dans un fichier de 5000 noms
Euler 023: somme des n>0 qui ne sont pas somme de deux abondants
Euler 024: N-ième permutation lexicographique de '0123456789'
Euler 025: indice du plus petit nombre Fibonacci F_{n} à N chiffres
Euler 026: pour quel d < N la période de 1/d est-elle maximum?
Euler 029: entiers distincts parmi les a^{b} avec a,b\) entiers, [latex]2\le a,b < N
Euler 030: entiers \ge2 sommes des puissances 5èmes de leurs chiffres
Euler 031: façons de payer une somme s avec des pièces d'une liste p
Euler 032: produits n=pq contenant une seule fois les chiffres 1 à 9
Euler 033: fractions xy/yz qui se simplifient en x/z
Euler 034: entiers qui sont sommes des factorielles de leurs chiffres

[Téléchargement introuvable]

# data[].attributes.attachment_link.description
J'ai écrit les documents suivants, que je mets à la disposition de tous. Dans la perspective des nouveaux programmes d'informatique pour tous, ils pourront être utiles aussi bien aux élèves qu'aux enseignants. Les conditions d'utilisation sont celles de la licence Creative Commons Si vous téléchargez plusieurs fois le même fichier, le compteur n'est incrémenté qu'une fois.

# data[].attributes.headline
Apprendre à programmer avec Python par Gérard Swinnen 370 pages

# data[].attributes.subject
Apprendre à programmer avec Python par Gérard Swinnen 370 pages

# data[].attributes.body
Outil pédagogique

# data[].attributes.attachment_link.title
Visualize Python, Java, JavaScript, C, C++, Ruby code execution

# data[].attributes.body
Tous les doc. des ateliers.

# data[].attributes.body
Yann Salmon

# data[].attributes.attachment_link.readable_text
Les adaptations du programme de seconde qui entrent en vigueur à la rentrée 2017 apportent des changements majeurs dans la façon d'aborder l'écriture d'algorithmes, qui se double de plus de l'écriture de programmes informatiques dans un langage textuel, concis, interprété et répandu (dixit le texte), ce qui est une assez bonne périphrase pour décrire Python3.

Le changement principal est l'abandon du triptyque saisie/traitement/affichage pour privilégier l'écriture de fonctions informatiques. Un document sur Eduscol contient de nombreuses ressources de qualité pour les professeurs mais il ne met pas vraiment en exergue ce changement de paradigme.

Dans ce billet, qui fait suite à celui de l'an dernier, j'explore au travers d'un exemple en quoi consiste ce changement et son intérêt.

Nombres premiers, nombres pseudo-premiers

L'exemple que j'ai choisi consiste à écrire des algorithmes pour déterminer si un naturel non nul est premier, s'il est pseudo-premier, et à déterminer le plus petit entier pseudo-premier sans être premier. Cet exemple vise uniquement à illustrer le changement dans la façon d'écrire les algorithmes en général ; j'ignore totalement si on peut traiter un exemple de ce niveau en seconde, mais la façon d'écrire les algorithmes se retrouvera dans tout autre exemple. De la même façon, je ne cherche pas ici à discuter de l'efficacité (complexité) des algorithmes ni à les optimiser d'une quelconque façon.

Je n'ai bien sûr pas besoin de rappeler ce qu'est un nombre premier.

Dans ce billet, on dira qu'un naturel non nul \(n\) est pseudo-premier si pour tout entier naturel \(a < n\), \(a^n - a\) est un multiple de \(n\). Le petit théorème de Fermat assure que si un entier est premier, alors il est pseudo-premier. Cependant, la réciproque n'est pas vraie : il existe des nombres qui sont pseudo-premiers sans être premiers, il en existe même une infinité.

Algorithmique à l'ancienne

Pour ne pas alourdir l'exposé, je vais écrire les algorithmes directement et seulement en Python, même si la façon d'écrire les algorithmes dans l'ancien programme de mathématiques semble avoir été contrainte par les possibilités des langages des calculatrices.

Voici comment on pourrait présenter un algorithme de calcul de primalité. Il y a peut-être plus pédagogique, mais la seule chose qui m'intéresse ici est la façon dont l'algorithme se comporte et va pouvoir (ou pas) se combiner à d'autres.

Sous réserve de faute de frappe de ma part, cet algorithme fonctionne : on peut s'en servir pour connaitre la primalité d'un entier.

On peut de même calculer la pseudo-primalité :

Ceci fonctionne aussi.

Mais comment peut-on maintenant écrire simplement un programme qui donne le plus petit naturel pseudo-premier sans être premier ? Il y a une idée simple : on parcourt les entiers dans l'ordre croissant ; pour chacun, on regarde s'il est pseudo-premier, et si tel est le cas on vérifie qu'il est premier : la première fois que cette vérification échoue correspond au nombre cherché.

On veut donc appeler de façon répétée les algorithmes écrits précédemment, cas très fréquent en informatique. Mais on ne peut pas : chaque fois qu'on va exécuter l'algorithme de primalité dans la boucle, celui-ci va nous demander de saisir à la main et au clavier un entier à traiter. C'est complètement ingérable !

On est obligé de recopier les parties pertinentes des deux premiers algorithmes dans un gigantesque algorithme pour répondre à la question posée. Outre que c'est ridicule, l'algorithme résultant de cela sera lourd et on ne comprendra pas facilement sa structure. Enfin, cet algorithme lui-même ne pourra pas être utilisé dans un autre : on ne s'en sort pas !

La nouvelle et bonne méthode

Le problème auquel nous faisons face ci-dessus tient au fait que nous avons programmé un algorithme qui s'occupe à la fois du traitement algorithmique (le calcul de primalité proprement dit) mais aussi des entrées et sorties.

Le langage Python, comme tous les langages modernes, permet d'exprimer un traitement à faire sans imposer la façon dont sont obtenus les paramètres ni la façon dont est utilisée le résultat : c'est la notion de fonction.

Il n'y a pas grand chose à changer. Pour le calcul de primalité :

Si on exécute ce programme, il ne se passe rien de visible. Mais il devient possible, dans la console Python, d'évaluer estPremier(7) et d'obtenir le résultat True.

De même pour la pseudo-primalité :

Et maintenant, on peut utiliser ces fonctions dans une autre !

Après avoir exécuté cette définition, on peut évaluer plusPetitPseudoPremierNonPremier(2) et obtenir 561.

Notez au passage que le texte que j'ai écrit entre triple guillemets est reproduit par la console Python si on exécute help(plusPetitPseudoPremierNonPremier) : c'est un très bon moyen de spécifier à un futur utilisateur de la fonction qu'on a écrite comment celui-ci doit s'en servir. Idéalement, il faut le faire pour chaque fonction qu'on écrit.

Conclusion

Le changement de paradigme opéré dans le programme de seconde nécessite de revoir entièrement la façon de présenter l'algorithmique et les algorithmes. Cependant les changements concrets à effectuer sont les mêmes à chaque fois et peuvent sans doute être apportés aux fiches d'activité de façon assez systématique.

Il ne s'agit pas nécessairement de traiter des exemples aussi avancés que celui que j'ai pris ; les activités actuellement utilisées vont probablement, pour la plupart, pouvoir être conservées en changeant simplement la façon d'écrire l'algorithme. Ainsi, même si la capacité à réutiliser les fonctions n'est pas immédiatement exploitée, le terrain sera préparé pour les années suivantes. À l'heure actuelle, les étudiants qui abordent l'informatique à un niveau plus complexe doivent commencer par désapprendre le triptyque saisie/traitement/affichage.

Bien sûr, ce changement suppose des modifications de fond dans la présentation initiale des choses, notamment l'introduction du concept de fonction. Cela n'est pas anodin dans la mesure où ce concept ne coïncide pas exactement avec celui de même nom en mathématiques, au risque d'une certaine confusion chez l'élève.

Il serait temps de dédier des heures spécifiques à l'enseignement de l'informatique et de recruter des professeurs spécialistes pour ce faire ; cela clarifierait les choses pour les élèves, dégagerait les collègues de math de la contrainte d'enseigner du mieux qu'ils peuvent des notions auxquelles ils n'ont pas eux-mêmes été formés et éviterait que cela empiète sur le temps consacré à l'enseignement des mathématiques proprement dites et notamment du raisonnement sans lequel il n'y a aucune informatique sérieuse possible (ni grand chose d'autre, du reste).

# data[].attributes.attachment_link.title
Les fonctions informatiques dans le nouveau programme de seconde

# data[].attributes.attachment_link.description
Les adaptations du programme de seconde qui entrent en vigueur à la rentrée 2017 apportent des changements majeurs dans la façon d'aborder l'écriture d'algorithmes, qui se double de plus de l'écriture de programmes informatiques dans un langage textuel, concis, interprété et répandu (dixit l...

# data[].attributes.body
Lien d'invitation.

# data[].attributes.attachment_link.description
Powerful and simple online compiler, IDE, interpreter, and REPL. Code, compile, and run code in 30+ programming languages. including JavaScript, Python, Ruby, Java, Node.js, Go, Clojure, Scheme, C, C#, C++, Lua and many more.

# data[].attributes.body
Dossier avec activités pour l'atelier de formation
http://bit.do/pythonlycee

# data[].attributes.attachment_link.title
Python au lycée - Formation coordo - Google Drive

# data[].attributes.body
ac-nantes 5 activités

# data[].attributes.attachment_link.title
Espace pédagogique : mathématiques - démarrer avec python

# data[].attributes.attachment_link.description
espace pédagogique > disciplines du second degré > mathématiques > enseignement > actions nationales > actions nationales 2017-2018

# data[].attributes.body
à retoucher (plein de print)

# data[].attributes.attachment_link.title
L'articulation collège-lycée en algorithmique dans un cadre interdisciplinaire

# data[].attributes.attachment_link.description
TraAM 2017-2018 - L'articulation collège-lycée en algorithmique dans un cadre interdisciplinaire

# data[].attributes.body
Trois activités - Pantaloni

# data[].attributes.body
Galerie de graphiques

# data[].attributes.attachment_link.title
Thumbnail gallery - Matplotlib 2.0.2 documentation

# data[].attributes.body
Python en ligne

# data[].attributes.attachment_link.readable_text
Skip to content

Build software collaboratively with the power of AI, on any device, without spending a second on setup

Join 20 million software creators building on Replit

Generate, edit, and explain code with Replit AI. Collaborate in our real-time multiplayer editor. Build, test, and deploy directly from the browser.

"Tightly integrated code generation, editing and output - well executed. Sets a high bar for computing education."

"The team at Replit are on fire as always - constantly seeing initiatives like this coming out that make me so excited to get coding and bring new ideas into my workshops and lessons 🔥"

"What Replit is doing in the DevEx space is a truly revolution and it will change how we develop apps."

"Lately, every time I open Replit, something new is added. I can really appreciate Replit when I think of the tremendous development costs I would have incurred if I had to make something like this myself."

"Replit has fulfilled my dreams of making tinkering with my code from my phone both viable and fun."

Code faster with AI

Built right into the editor, Replit AI enables you to debug, autocomplete, and turn natural language into code with one-click.

# data[].attributes.attachment_link.title
Replit: The software creation platform. IDE, AI, and Deployments

# data[].attributes.attachment_link.description
Run code live in your browser. Write and run code in 50+ languages online with Replit, a powerful IDE, compiler, & interpreter.

# data[].attributes.body
Tutoriel GIF animé

# data[].attributes.body
Traduction interactive

# data[].attributes.attachment_link.description
Teach using blocks in the browser. No installation required.