La Pythonerie

La Pythonerie apprendre à programmer en français v. 2026.10.16.16.36

Chargement de LispE… 📖 Mode d'emploi

Projet

—

Code LispE produit

Canevas 800 × 600

Console

📖 Pour apprendre pas à pas, lis le mode d'emploi : il explique tout simplement, avec des exemples à essayer, et contient le glossaire de tous les mots.

L'écran et les raccourcis

`Ctrl`+`Entrée`	exécute le programme (comme ▶ Exécuter)	`Ctrl`+`Espace`	propose des mots ; une fonction choisie arrive avec ses arguments, le premier sélectionné
clic droit sur une fonction	va à sa définition, dans ce programme ou dans un autre programme du projet (pas pour une fonction prédéfinie) ; ↩ Retour ramène là où tu étais	sélectionner une fonction	montre ses arguments en bas de l'éditeur
`Ctrl`+`/`	met une ligne en commentaire, ou l'en sort	⛶	met l'éditeur, la console ou le canevas en plein écran (✕ ou `Échap` pour revenir)
`>>>`	sous la console : exécute tout de suite une ligne, avec les variables du dernier programme (`notes`, `longueur(notes)`…)	`Maj`+`Entrée` · `↑` `↓`	dans la ligne `>>>` : passe à la ligne · rappelle les commandes déjà tapées
▦ Données	montre les onglets de données du projet (puis ✎ Code pour revenir)	λ LispE	montre le code LispE produit, avec ses numéros de ligne
▤ Console	en plein écran du canevas : fait venir la console dessous	■ Arrêter	arrête une animation (ou `arrête()` dans le programme)

Le langage

Un bloc est décalé de 4 espaces. La ligne qui l'ouvre se termine par :, et l'on va toujours à la ligne après : rien ne s'écrit à droite du :.

# Un commentaire
âge = 12
nom = "Léa"
affiche("Bonjour", nom)
affiche(f"{nom} a {âge} ans")

si âge >= 18:
    affiche("majeur")
sinonsi âge >= 12:
    affiche("ado")
sinon:
    affiche("enfant")

pour i dans intervalle(5):
    affiche(i)

n = 0
tantque n < 3:
    n += 1
    si n == 2:
        continuer   # tour suivant
    # sortir : quitte la boucle

fonction carré(x):
    retourne x * x

def cube(x):       # def marche aussi
    retourne x ** 3

notes = [12, 15, 9]
notes.ajoute(18)
affiche(longueur(notes), somme(notes))
pairs = [x pour x dans intervalle(10) si x % 2 == 0]
âge = {"Léa": 12, "Tom": 11}
affiche(âge["Léa"])

si 15 dans notes et non (20 dans notes):
    affiche("oui")

essaie:
    lever "problème !"
sauf(e):
    affiche("erreur :", e)

classe Chien:
    def __init__(soi, nom):
        soi.nom = nom
    def aboie(soi):
        affiche(soi.nom, ": Ouaf !")

rex = Chien("Rex")
rex.aboie()

ok = Vrai     # Vrai, Faux, Rien
nom = "Tom"
selon (nom):
    cas "Léa":
        affiche("Salut Léa")
    cas "Tom":
        affiche("Salut Tom")
    défaut:
        affiche("Bonjour", nom)

Opérateurs	`+ - * / // % *` · `+= -= = /=`	Comparaisons	`== != < <= > >=`
Logique	`et ou non` · `dans`, `non dans`	Erreurs	`essaie:` … `sauf:` (ou `sauf(e):` pour lire le message) · `lever "…"`
Dans une fonction	`x = …` crée une variable locale ; `x =: …` change celle du programme	Copier	`clone(l)` : une vraie copie d'une liste ou d'un dictionnaire

Les noms gardent leurs accents : épaisseur, carré, va_à. Une boucle tantque qui ne s'arrête jamais est stoppée après 10 millions de tours, avec un message : pour un jeu, utilise animer.

Fonctions utiles

`affiche(a, b…)`	écrit dans la console (`écris` : sans aller à la ligne)	`demande("Question ?", f)`	une petite fenêtre pose la question ; f(réponse) quand on a répondu
`demande_nombre("…", f)`	f reçoit un nombre	`lire("Question ?", f)`	pose la question dans la console ; f(réponse) quand on a répondu
`assigne(nom, valeur)`	range la valeur dans la variable nom	`longueur(x)`	taille d'une liste ou d'un texte
`intervalle(a, b, pas)`	les nombres de a à b (b exclu)	`aléatoire(a, b)` · `hasard()`	un entier entre a et b · un réel entre 0 et 1
`entier(x) réel(x) chaîne(x)`	conversions	`arrondi(x, n)`	arrondi à n décimales
`racine(x) absolu(x)`	mathématiques	`sinus(a) cosinus(a)`	angles en degrés
`somme(l) maximum(l) minimum(l)`	sur une liste	`trie(l) inverse(l) choisis(l)`	listes
`majuscules(t) minuscules(t)`	texte	`découpe(t, " ") remplace(t, a, b)`	texte
`typede(x)`	le genre de x, en français : `"entier"`, `"texte"`, `"liste"`, `"dictionnaire"`…	`en_json(x)` · `analyse_json(t)`	une valeur en JSON, et l'inverse

Les instructions de LispE en français (…)

Ces noms sont d'autres noms des instructions de LispE (voir basic/français.lisp). La dernière colonne donne le nom LispE, celui qui apparaît dans « λ LispE ». Les angles sont en radians, sauf pour sinus et cosinus.

Le dessin

Le canevas mesure 800 × 600 ; (0, 0) est en haut à gauche et y descend. Survole-le pour voir les coordonnées. canevas(400, 400) change sa taille ; largeur(), hauteur() la donnent. appareil() dit sur quoi tourne le programme, pour l'adapter : ["tablette", 1180, 820] ("ordinateur", "tablette" ou "téléphone", puis la largeur et la hauteur de l'écran, dans le sens où on le tient).

`efface()` · `fond("bleu clair")`	page blanche · peint tout le fond	`couleur("rouge")` · `rgb(255, 128, 0)`	couleur des formes · couleur sur mesure
`épaisseur(4)` · `point(x, y)`	épaisseur du trait · un point	`ligne(x1, y1, x2, y2)`	un segment
`rectangle(x, y, l, h)` · `carré(x, y, c)`	contours (`_plein` : coloriés)	`cercle(x, y, r)` · `disque(x, y, r)`	contour · rond colorié
`ellipse(x, y, rx, ry)` · `triangle(…)`	(`ellipse_pleine`, `triangle_plein`)	`polygone([[x, y], …])`	(`polygone_plein`)
`texte(x, y, "Bonjour")`	écrit dans le canevas	`taille_texte(30)` · `police("serif")`	style du texte ; `largeur_texte(t)` : sa largeur en points
`couleur_pixel(x, y)`	la couleur d'un point : [rouge, vert, bleu, opacité]	`pixels(x, y, l, h)` · `pose_pixels(…)`	lit les points d'un rectangle · les redessine

Couleurs : rouge, vert, bleu, jaune, orange, violet, rose, marron, noir, blanc, gris, cyan, magenta, turquoise, beige, or, argent, bleu marine, et leurs nuances « clair » et « foncé » — ou une couleur CSS ("#ff8800").

La tortue

`avance(100) recule(50)`	se déplace en dessinant	`gauche(90) droite(45)`	tourne (degrés)
`lève_crayon() baisse_crayon()`	dessine ou non	`va_à(x, y) oriente(angle)`	position et direction
`origine()`	retour au centre	`cache_tortue() montre_tortue()`	visibilité
`position()`	[x, y] de la tortue	`cap()`	sa direction, en degrés

Animation, souris, clavier et objets

x = 0
couleur_balle = "rouge"

fonction bouge():
    x =: x + 5          # =: change la variable x du programme
    efface()
    couleur(couleur_balle)
    disque(x % 800, 300, 30)

fonction clic(cx, cy):
    couleur_balle =: choisis(["rouge", "vert", "bleu"])

animer(bouge, 30)       # toutes les 30 millisecondes
quand_clic(clic)

`quand_clic(f)` · `quand_souris(f)` · `quand_glisse(f)`	`f(x, y)` au clic, quand la souris bouge, quand on la fait glisser	`quand_touche(f)` · `quand_relâche(f)`	`f(touche)` : "gauche", "droite", "haut", "bas", "espace", "entrée", "a"…
`touche_enfoncée("gauche")`	Vrai tant que la touche est tenue : à tester dans la fonction d'`animer`	`arrête()`	arrête les animations
`bouton(clef, x, y, texte, f)`	un bouton ; un clic appelle `f(clef, texte)`	`bouton_image(clef, x, y, image, f)`	un bouton qui a l'aspect d'une image (une seconde image : son aspect appuyé)
`saisie(clef, x, y, f)`	un champ de saisie ; Entrée appelle `f(clef, valeur)`	aussi	`case_à_cocher`, `bouton_radio`, `glissière`, `liste_déroulante`, `liste_hiérarchique`, `zone_édition`
`valeur_objet(clef)` · `change_objet(clef, v)`	lit ou change la valeur d'un objet	`retire_objet(clef)` · `retire_objets()`	enlève un objet, ou tous
`affiche_console()` · `cache_console()`	montre la console, même en plein écran du canevas · la renvoie	`efface_console()`	vide la console

Les dessins

`d = nouveau_dessin()`	un dessin vide, qu'on prépare avant de le montrer	`d.disque(x, y, r)` · `d.couleur(c)` · `d.avance(n)`	ajoute la commande au dessin sans rien dessiner (toutes les instructions de dessin et de la tortue)
`montre_dessin(d)`	dessine tout le dessin d'un coup ; le remontrer à chaque image ne coûte presque rien	`vide_dessin(d)`	retire toutes ses commandes

La 3D

`s = nouvelle_scène()`	une scène vide	`s.cube(x, y, z, côté, c)` · `s.sphère(x, y, z, r, c)`	de nouveaux objets dans la scène (aussi boîte, cylindre, cône, anneau) ; chacun donne son numéro
`g = s.groupe(x, y, z)`	un nouveau groupe : `g.sphère(…)` y ajoute un objet, et ils bougent ensemble	`s.lumière(x, y, z)` · `s.caméra(x, y, z, vx, vy, vz)`	une lampe · la caméra et ce qu'elle regarde
`montre_3d(s)`	montre la scène, sous la 2D	`o.tourne(ax, ay, az)` · `o.déplace(x, y, z)`	dans animer : fait tourner, déplace
`o.texture(img)` · `o.lumineux()`	une image sur l'objet · il brille	`caméra_libre()` · `quand_clic_objet(f)`	la souris pilote la caméra · f(numéro) au clic

Images, sons et pages

`img = charge_image("chat.png")`	charge une image et donne son numéro	`place_image(img, x, y)`	la dessine (coin en haut à gauche) ; avec `l, h` : à cette taille
`snd = charge_son("bravo.wav")`	charge un son et donne son numéro	`joue_son(snd)`	joue le son
`liste_images()` · `liste_sons()`	les noms des images, des sons du projet et du site	`capture_image(x, y, l, h)`	un rectangle du dessin devient une image
`ouvre_page("https://…")`	ouvre une page dans un nouvel onglet (depuis un clic)

Un nom seul ("chat.png") désigne un fichier des répertoires images ou sons du projet ; un chemin, un fichier du site (exemples/médias/ding.wav) ; https://…, une adresse Internet.

Fichiers et données

`t = charge_données("notes.csv")`	le texte d'un fichier du répertoire données	`sauve_données("notes.csv", t)`	l'écrit (ou le remplace) dans ce répertoire
`don0`, `don1`…	le texte des onglets de données (bouton ▦ Données)	`range_données("don1", v)` · `prend_données("don1")`	écrit dans un onglet · le relit
`lit_fichier(f)`	un fichier de l'ordinateur, choisi dans une fenêtre ; f(texte) le reçoit	`écrit_fichier("scores", t)`	enregistre le texte dans Téléchargements
`sauve_dans_serveur(prof, chemin, v)`	envoie v au professeur, sur serveur.py (sans pouvoir la relire)	`liste_dans_serveur` · `lit_dans_serveur`	mode administrateur : ce que les élèves ont envoyé
`login()`	le nom de l'élève (« Unique » en mode utilisateur unique)	`sauve_élèves(liste, f)`	mode administrateur : la liste des élèves de la classe
`importe "outils"`	ajoute le code du programme « outils » du projet	`charge_programme` · `sauve_programme`	lit ou écrit un programme du projet

Le projet

Le projet réunit les programmes et trois répertoires : images, sons et données. On y glisse des fichiers, ou on clique sur ＋.
Un clic sur le nom du projet ouvre Mes projets : les projets gardés dans ce navigateur. Le projet que l'on quitte y est rangé tout seul.
📚 Matériels et 🧪 Exemples, au bas de la colonne : le matériel de l'enseignant, et vingt exemples : un clic en ouvre un, dans un projet à son nom, qui n'entre dans Mes projets que si tu le renommes.
L'icône ⧉ copie un programme ou un fichier ; dans un autre projet, 📋 Coller (ou Cmd/Ctrl+V) le recopie.

Les actions du menu ☰

Nouveau projet · Renommer · Supprimer	un projet vide avec un nom · change son nom · l'efface
Exporter le projet	un fichier `.zip` dans Téléchargements, avec les programmes, les données, les images et les sons (un projet sans nom en reçoit un d'abord)
Exporter pour un courriel	le même projet en un seul fichier texte `.json` : les messageries refusent souvent les `.zip`, pas les fichiers texte (les images et les sons y sont un tiers plus gros) ; il s'ouvre comme un `.zip`, avec Charger un projet
📤 Envoyer le projet (le bouton à côté du nom du projet)	ouvre le partage de l'appareil (Mail, Messages, AirDrop…) avec le projet en un seul fichier ; sans partage dans le navigateur, le fichier est téléchargé, à joindre soi-même
Charger un projet · Coller un projet (JSON)	ouvre un `.zip` ou un `.json` à la place du projet en cours · un projet écrit en texte, comme ceux que prépare Claude
Créer une application Web	fait d'un programme (le principal, s'il y en a plusieurs) un petit site autonome : un zip à décompresser et à mettre sur un site Web (voir son `LISEZMOI.txt`)
Revenir au projet précédent	rouvre le dernier projet quitté
Archiver tous mes projets · Charger une archive	tous les projets dans un seul fichier · les fusionne avec la liste (pour un nom déjà pris, on choisit)

Plusieurs élèves sur le même ordinateur

Par défaut, la Pythonerie est en mode Utilisateur unique : pas de connexion, l'utilisateur s'appelle « Unique ». Pour un ordinateur partagé, décoche Utilisateur unique dans le menu ☰ : chaque élève tape son nom (bouton 👤) avant d'exécuter du code, et ne voit que ses projets. Un deuxième clic sur 👤 le déconnecte : son projet rejoint sa liste, et l'écran est vidé pour l'élève suivant. Avec "multi_utilisateur": true dans config.json, ce mode est imposé à tout le monde. Avec serveur.py, une copie des projets exportés est gardée pour l'enseignant.

🔒 Protection des données

La Pythonerie est compatible avec le RGPD et ses équivalents canadiens (LPRPDE, Loi 25 du Québec) : tout s'exécute dans le navigateur. Une fois la page chargée, rien ne transite par le réseau ; les programmes et le nom de l'élève restent sur l'ordinateur. Il n'y a ni cookie, ni mesure d'audience, ni service tiers (l'éditeur et les polices sont fournis par le site).

Crédits

La Pythonerie a été créée par Claude Roux. Il est aussi l'auteur de LispE, le langage dans lequel les programmes sont traduits puis exécutés, directement dans le navigateur (en WebAssembly). © 2026 Claude Roux, licence BSD 3 clauses.

CodeMirror, l'éditeur de code : Marijn Haverbeke et ses contributeurs, licence MIT.
three.js, la 3D : les auteurs de three.js, licence MIT.
Les polices Inter et JetBrains Mono : SIL Open Font License 1.1.
Les images des matériels : les textures des planètes de Solar System Scope (CC BY 4.0), la surface de l'astéroïde Bennu par la NASA (NASA/Goddard/University of Arizona, domaine public), les images de la pile « Les déclinaisons latines », de Wikimedia Commons (auteurs et licences sur sa dernière carte).

Aide de la Pythonerie