Mode d'emploi de la Pythonerie

👋 Bienvenue !

Un programme, c'est une liste d'ordres que tu donnes à l'ordinateur. L'ordinateur les suit, un par un, dans l'ordre.

Dans la Pythonerie, tu écris ces ordres en français. Tu peux faire des calculs, écrire des messages, dessiner, faire bouger une tortue et même créer de petits jeux.

🖥️ L'écran

L'écran de la Pythonerie a trois parties.

En haut, le bouton ▶ Exécuter lance ton programme. Le bouton ■ Arrêter arrête une animation. Le bouton ❓ Aide montre un résumé de tous les mots.

Le bouton ⛶, au-dessus de l'éditeur, met ton programme en plein écran, pour avoir plus de place. Celui de la console fait de même pour la console ; la console en plein écran a alors son bouton ▶ Exécuter, qui devient ■ Arrêter tant que le programme tourne. Pour revenir, clique sur ✕ ou appuie sur Échap. Quand tu cliques sur ▶ Exécuter, l'éditeur quitte le plein écran, pour que tu voies ce que fait ton programme.

🚀 Ton premier programme

1. Clique sur ＋ Nouveau, à gauche.
2. Donne un nom à ton programme, par exemple Bonjour.
3. Dans l'éditeur, écris :

affiche("Bonjour !")

4. Clique sur ▶ Exécuter.

Bravo ! 🎉 Tu viens d'écrire ton premier programme.

🐞 Les erreurs

Tout le monde fait des erreurs, même les grands programmeurs. Ce n'est pas grave !

Quand l'ordinateur ne comprend pas, il écrit un message rouge dans la console. Lis-le : il t'aide à trouver ce qui ne va pas.

• As-tu bien fermé tous les guillemets " et toutes les parenthèses ) ?
• As-tu mis les deux-points : à la fin de la ligne d'un si ou d'un pour ?
• As-tu écrit les mots avec leurs accents ? On écrit épaisseur, pas epaisseur.
• Les lignes décalées vers la droite ont-elles toutes le même décalage ?

💬 Écrire des messages

affiche écrit dans la console. Tu peux afficher plusieurs choses à la fois, en les séparant par des virgules.

affiche("J'ai", 7, "ans")
affiche("2 + 3 =", 2 + 3)

Le texte s'écrit entre guillemets : "comme ceci". Les nombres s'écrivent sans guillemets.

Une ligne qui commence par # est un commentaire. L'ordinateur ne la lit pas : c'est une petite note pour toi.

# Ceci est une note pour moi
affiche("Coucou")

📦 Les boîtes (variables)

Une variable, c'est comme une boîte avec une étiquette. Tu ranges quelque chose dedans, et tu le retrouves grâce à l'étiquette.

prénom = "Léa"
âge = 8
affiche(prénom, "a", âge, "ans")

Le signe = veut dire : « range ceci dans la boîte ». Tu peux changer le contenu de la boîte quand tu veux :

points = 0
points = points + 10
points += 5        # c'est la même chose que : points = points + 5
affiche(points)

Pour mettre une boîte dans un texte, écris un f devant les guillemets et le nom de la boîte entre accolades { } :

prénom = "Tom"
affiche(f"Bonjour {prénom} !")

🔎 Regarder dans une boîte

Sous la console, il y a une ligne qui commence par >>>. C'est la ligne de commande : ce que tu y tapes est exécuté tout de suite, quand tu appuies sur Entrée.

Après avoir exécuté ton programme, tape le nom d'une boîte pour voir ce qu'il y a dedans :

>>> prénom
"Léa"
>>> âge + 1
9

Tu peux aussi y essayer une idée sans changer ton programme : x = 5, puis x * 10, ou même disque(400, 300, 50) pour dessiner.

🧮 Calculer

L'ordinateur est très fort en calcul !

Attention : un nombre à virgule s'écrit avec un point : 3.5.

bonbons = 17
enfants = 5
affiche("Chacun reçoit", bonbons // enfants, "bonbons")
affiche("Il en reste", bonbons % enfants)

❓ Poser une question

Imagine que tu as une partie de football ou de hockey, et que l'un de tes parents doit t'y conduire. Il a deux possibilités : rester jusqu'à la fin de la partie, et alors sa journée est bloquée ; ou te dire « appelle-moi quand tu as fini », et alors il est libre d'aller travailler ou de faire les courses pendant que tu joues.

Ton programme fait comme le second parent. Quand il pose une question, il n'attend pas ta réponse : il continue son travail. Tu lui donnes une fonction, la fonction de rappel, et la Pythonerie l'appelle avec ta réponse, quand tu as répondu. Pendant ce temps, rien n'est bloqué : les animations tournent, les sons jouent.

demande pose la question dans une petite fenêtre, sur le canevas : tape ta réponse, puis appuie sur Entrée (Échap abandonne la question).

fonction répond(nom):
    affiche("Enchanté,", nom)

demande("Comment t'appelles-tu ?", répond)
affiche("Le programme a continué sans attendre !")

Pour une réponse qui est un nombre, utilise demande_nombre. Pour poser une deuxième question après la première, pose-la dans la fonction de rappel :

fonction prénom(nom):
    affiche("Bonjour", nom)
    demande_nombre("Quel âge as-tu ?", âge)

fonction âge(n):
    affiche("L'an prochain, tu auras", entier(n) + 1, "ans")

demande("Comment t'appelles-tu ?", prénom)

lire fait la même chose, mais pose la question dans la console : la ligne juste en dessous, marquée d'un ?, attend ta réponse. lire_nombre donne un nombre.

Un argument de plus, après la fonction, lui est donné avec la réponse : demande("Question ?", f, a) appelle f(réponse, a). Une même fonction peut ainsi servir à plusieurs questions. Avec assigne(nom, valeur), elle peut même ranger chaque réponse dans la variable qui s'appelle nom :

nom = ""
ville = ""
fonction range(réponse, variable):
    assigne(variable, réponse)
    affiche(variable, "vaut maintenant", réponse)

demande("Ton nom ?", range, "nom")
demande("Ta ville ?", range, "ville")

Les questions posées l'une après l'autre attendent leur tour : la deuxième vient quand tu as répondu à la première. ■ Arrêter les abandonne toutes.

🔀 Choisir avec si

Parfois, il faut faire une chose seulement si quelque chose est vrai.

âge = 8
si âge >= 6:
    affiche("Tu vas à l'école")
sinon:
    affiche("Tu es encore petit")

Avec sinonsi, tu peux tester plusieurs choses l'une après l'autre :

note = 15
si note >= 16:
    affiche("Excellent !")
sinonsi note >= 10:
    affiche("Bien !")
sinon:
    affiche("Il faut encore travailler")

Pour comparer

🔁 Répéter

Pour répéter des ordres plusieurs fois, on fait une boucle.

Répéter un nombre de fois avec pour

pour i dans intervalle(1, 6):
    affiche("Je compte :", i)

intervalle(1, 6) donne les nombres de 1 à 5. Le dernier nombre, 6, n'est pas compris. intervalle(5) donne 0, 1, 2, 3, 4.

Répéter tant que c'est vrai avec tantque

fusée = 5
tantque fusée > 0:
    affiche(fusée)
    fusée -= 1
affiche("Décollage ! 🚀")

sortir quitte la boucle tout de suite. continuer passe directement au tour suivant.

📚 Les listes

Une liste range plusieurs choses dans une seule boîte. On l'écrit entre crochets [ ].

fruits = ["pomme", "poire", "cerise"]
affiche(fruits[0])          # le premier fruit
affiche(longueur(fruits))   # combien de fruits ?
fruits.ajoute("kiwi")       # on ajoute un fruit à la fin
pour fruit dans fruits:
    affiche("J'aime :", fruit)

Attention : on compte à partir de 0. fruits[0] est le premier, fruits[1] le deuxième. fruits[-1] est le dernier.

Les méthodes

Quand une fonction s'écrit après un point, comme fruits.ajoute("kiwi"), on l'appelle une méthode. fruits.ajoute("kiwi") fait la même chose que ajoute(fruits, "kiwi"). Tu peux utiliser ainsi toutes les fonctions du glossaire : mot.majuscules(), notes.somme()…

Les dictionnaires

Un dictionnaire range des choses avec un nom. On l'écrit entre accolades { }.

animaux = {"chat": "miaou", "chien": "ouaf"}
affiche("Le chat fait", animaux["chat"])

🍰 Les fonctions

Une fonction, c'est comme une recette : tu lui donnes un nom une fois, puis tu peux l'utiliser autant de fois que tu veux.

fonction salue(prénom):
    affiche("Bonjour", prénom, "!")

salue("Léa")
salue("Tom")

Une fonction peut aussi rendre un résultat avec retourne :

fonction double(n):
    retourne n * 2

affiche(double(21))

🎨 Dessiner

Le canevas, à droite, est une feuille de 800 points de large et 600 points de haut. Pour dire où dessiner, on donne deux nombres : x et y.

• x dit combien on va vers la droite.
• y dit combien on va vers le bas.
• Le coin en haut à gauche est le point (0, 0).

Tu veux une feuille d'une autre taille ? Écris canevas(largeur, hauteur) au début de ton programme. canevas(400, 400) te donne une feuille carrée de 400 sur 400. Le dessin est effacé et la tortue revient au milieu. largeur() et hauteur() te disent toujours la taille de la feuille : disque(largeur() / 2, hauteur() / 2, 50) dessine un rond au milieu, quelle que soit sa taille. À chaque exécution, la feuille reprend sa taille de 800 sur 600.

fond("bleu clair")          # le ciel
couleur("jaune")
disque(650, 120, 60)        # le soleil
couleur("vert")
rectangle_plein(0, 450, 800, 150)   # l'herbe
couleur("rouge")
triangle_plein(300, 450, 500, 450, 400, 300)  # une tente

Les couleurs : rouge, vert, bleu, jaune, orange, violet, rose, marron, noir, blanc, gris, cyan, magenta, turquoise, beige, or, argent, bleu marine, et leurs nuances avec clair ou foncé : rouge clair, rouge foncé, vert clair, vert foncé, bleu clair, bleu foncé, jaune clair, jaune foncé, orange clair, orange foncé, violet clair, violet foncé, rose clair, rose foncé, marron clair, marron foncé, gris clair, gris foncé. Tu peux aussi inventer une couleur avec rgb(rouge, vert, bleu), chaque nombre allant de 0 à 255.

🐢 La tortue

Une petite tortue se promène sur le canevas. Elle part du milieu et regarde vers la droite. Partout où elle passe, elle laisse un trait.

# Un carré
pour i dans intervalle(4):
    avance(100)
    droite(90)

• avance(100) : la tortue avance de 100 points.
• droite(90) : elle tourne d'un quart de tour vers la droite. gauche(90) vers la gauche.
• lève_crayon() : elle se déplace sans dessiner. baisse_crayon() : elle dessine à nouveau.

🎬 Animer

Pour faire bouger un dessin, on le redessine très vite, un peu plus loin à chaque fois, comme dans un dessin animé. animer appelle ta fonction encore et encore.

x = 0

fonction image():
    x += 5
    efface()
    couleur("orange")
    disque(x % 800, 300, 30)

animer(image, 30)    # toutes les 30 millisecondes

Clique sur ■ Arrêter pour arrêter l'animation.

🖱️ Souris et clavier

Ton programme peut réagir quand tu cliques ou quand tu appuies sur une touche.

fonction clic(x, y):
    couleur(choisis(["rouge", "vert", "bleu"]))
    disque(x, y, 20)

quand_clic(clic)    # à chaque clic, une bulle de couleur

Avec quand_touche(f), ta fonction f(touche) reçoit le nom de la touche : "gauche", "droite", "haut", "bas" pour les flèches, "espace" pour la barre d'espace, "entrée", "échap", "retour arrière"… et "a" pour la lettre a, "7" pour le chiffre 7. Clique d'abord sur le canevas, puis appuie sur les touches.

🎮 Tenir une touche enfoncée

Quand tu gardes une touche appuyée, quand_touche la reçoit une fois, puis, après un petit moment, encore et encore : c'est l'ordinateur qui la répète, et un jeu avance alors par à-coups. Pour un mouvement doux, demande plutôt, à chaque image de ton animation, si la touche est tenue : touche_enfoncée(nom) donne Vrai tant qu'elle est enfoncée.

x = 400

fonction image():
    si touche_enfoncée("gauche"):
        x -= 5
    si touche_enfoncée("droite"):
        x += 5
    fond("bleu marine")
    couleur("jaune")
    disque(x, 300, 30)

animer(image, 20)     # clique dans le canevas, puis tiens une flèche

Tu peux tenir plusieurs touches à la fois : touche_enfoncée("haut") et touche_enfoncée("gauche") sont alors vraies toutes les deux. Et quand_relâche(f) appelle f(touche) au moment où tu lâches une touche, avec le même nom qu'à l'appui. Garde quand_touche pour ce qui ne se fait qu'une fois, comme tirer.

✍️ Un champ pour écrire dans le canevas

saisie(clef, x, y, f) pose un champ de saisie dans le canevas, au point (x, y) : c'est une petite case où l'on peut taper du texte. La clef est le nom du champ. Quand tu appuies sur Entrée, ou quand tu cliques dans un autre champ, ta fonction est appelée : f(clef, valeur). La clef te dit quel champ a changé, et la valeur est ce que tu as tapé, toujours sous forme de texte (utilise entier(valeur) pour avoir un nombre).

fonction reçu(clef, valeur):
    si clef == "nom":
        affiche("Bonjour", valeur, "!")
    sinonsi clef == "âge":
        affiche("Dans un an, tu auras", entier(valeur) + 1, "ans.")

texte(100, 75, "Ton nom :")
saisie("nom", 100, 100, reçu)
texte(100, 155, "Ton âge :")
saisie("âge", 100, 180, reçu)

Pour un nombre à virgule, utilise nombre(valeur) : il accepte 2,5 comme 2.5, et donne 0 si ce n'est pas un nombre.

Trois autres fonctions t'aident à passer d'un champ à l'autre :

• active_saisie(clef) met le curseur dans ce champ, comme si tu avais cliqué dessus. Ce que tu tapes remplace son contenu. Le champ que tu quittes envoie sa valeur, si elle a changé.
• saisie_active() te dit quel champ a le curseur ("" s'il n'y en a pas).
• largeur_saisie(l) choisit la largeur des champs que tu crées ensuite (200 au départ).
• Un champ prend la police et la taille du texte du moment : écris police("serif") ou taille_texte(30) avant saisie(…) pour changer ses lettres.

Dans un champ, les flèches haut et bas et la touche Entrée vont aussi à quand_touche ; gauche et droite aussi, quand le curseur est au bord du texte. C'est ainsi que l'exemple 18. Un mini tableur passe d'une case à l'autre avec les flèches.

🧩 Boutons, cases, listes et autres objets

Comme un champ de saisie, tu peux poser dans le canevas d'autres objets que l'on manipule à la souris. Chacun a une clef (son nom), se place au point (x, y), prend la police et la taille du texte du moment, et appelle ta fonction quand on s'en sert. Cette fonction reçoit toujours deux valeurs : une même fonction peut donc servir à plusieurs objets.

• 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, à sa taille ; un clic appelle f(clef, image). Avec bouton_image(clef, x, y, image, image_appuyée, f), il prend un second aspect tant qu'on appuie dessus. Une image transparente (png, svg) donne un bouton de n'importe quelle forme.
• case_à_cocher(clef, x, y, texte, f) : une case ; f(clef, coché) reçoit Vrai ou Faux.
• bouton_radio(clef, groupe, x, y, texte, f) : dans un même groupe, un seul bouton est choisi à la fois ; en choisir un appelle f(groupe, clef).
• glissière(clef, x, y, mini, maxi, valeur, f) : une réglette qui va de mini à maxi ; f(clef, valeur) pendant qu'on la déplace.
• liste_déroulante(clef, x, y, éléments, f) : une liste où l'on choisit un élément ; f(clef, choix).
• liste_hiérarchique(clef, x, y, lignes, arbre, f) : une liste en arbre, que l'on déplie. Un élément est un texte, ou [nom, [enfants…]] pour un groupe. Un clic appelle f(clef, chemin) : chemin est la liste des noms depuis le haut, par exemple ["Fruits", "pomme"], et chemin[-1] est l'élément cliqué.
• zone_édition(clef, x, y, lignes, f) : un texte sur plusieurs lignes (Entrée passe à la ligne) ; f(clef, texte) quand tu quittes la zone, ou avec Ctrl+Entrée.

valeur_objet(clef) lit la valeur d'un objet à tout moment, et change_objet(clef, valeur) la change : voir Lire et changer la valeur d'un objet, plus bas. retire_objet(clef) enlève un objet du canevas, et retire_objets() les enlève tous (pour passer d'un écran à un autre, par exemple).

fonction choisi(clef, valeur):
    affiche(clef, ":", valeur)

taille_texte(16)
bouton("ok", 20, 20, "Bonjour !", choisi)
case_à_cocher("son", 20, 70, "Avec le son", choisi)
bouton_radio("petit", "taille", 20, 110, "Petit", choisi)
bouton_radio("grand", "taille", 20, 140, "Grand", choisi)
glissière("vitesse", 20, 180, 1, 10, 5, choisi)
liste_déroulante("animal", 20, 220, ["chat", "chien", "lapin"], choisi)
liste_hiérarchique("aliments", 300, 20, 6, [["Fruits", ["pomme", "poire"]], ["Légumes", ["carotte", "salade"]], "Pain"], choisi)

L'exemple 20. L'atelier de formes se sert de tous ces objets à la fois. Ses boutons de formes sont des bouton_image : le programme dessine chaque icône, la copie avec capture_image, et sa pipette lit la couleur d'un point avec couleur_pixel.

🔁 Lire et changer la valeur d'un objet

Un objet du canevas garde lui-même sa valeur : le texte tapé dans un champ, l'élément choisi dans une liste, la case cochée ou non, la position de la glissière… Ce n'est pas une variable de ton programme : c'est l'objet, dans la page, qui la retient. Ta fonction la reçoit quand on se sert de l'objet ; mais ton programme peut aussi, à tout moment :

• la lire : valeur_objet(clef) donne ce que l'objet contient maintenant ;
• la changer : change_objet(clef, valeur) change ce que l'objet montre. Sa fonction n'est pas appelée : c'est ton programme qui change l'objet, pas l'élève qui s'en sert.

Une fiche à remplir. Un champ de saisie n'envoie sa valeur à sa fonction que quand on appuie sur Entrée. Pour une fiche, le plus simple est donc de laisser l'élève tout remplir, puis de lire tous les objets d'un coup quand il clique sur « Valider ». « Effacer » change chaque objet pour le remettre comme au départ. Remplis la fiche, clique sur Valider, puis sur Effacer :

# Une fiche : on remplit les objets, puis « Valider » lit tout ce qu'ils contiennent
fonction attend(clef, valeur):
    retourne Rien          # rien à faire pendant qu'on remplit la fiche

fonction commande(clef, texte):
    si clef == "valider":
        # valeur_objet lit ce que chaque objet contient MAINTENANT
        nom = valeur_objet("nom")            # le texte tapé dans le champ
        la_classe = valeur_objet("classe")   # l'élément choisi dans la liste
        âge = valeur_objet("âge")            # la position de la glissière (un nombre)
        cantine = valeur_objet("cantine")    # Vrai si la case est cochée
        affiche(f"{nom}, {âge} ans, en {la_classe}")
        si cantine:
            affiche("mange à la cantine")
    sinon:
        # change_objet remet chaque objet dans son état de départ
        change_objet("nom", "")
        change_objet("classe", "CM1")
        change_objet("âge", 10)
        change_objet("cantine", Faux)
        affiche("— la fiche est effacée")

taille_texte(16)
texte(20, 25, "Prénom :")
saisie("nom", 120, 20, attend)
texte(20, 75, "Classe :")
liste_déroulante("classe", 120, 70, ["CP", "CE1", "CE2", "CM1", "CM2"], attend)
change_objet("classe", "CM1")
texte(20, 125, "Âge :")
glissière("âge", 120, 120, 6, 12, 10, attend)
case_à_cocher("cantine", 20, 170, "Mange à la cantine", attend)
bouton("valider", 20, 220, "Valider", commande)
bouton("effacer", 140, 220, "Effacer", commande)

Deux objets qui se suivent. Ici, une glissière et un champ montrent le même nombre : quand l'un change, le programme met l'autre à jour avec change_objet. Comme change_objet n'appelle pas la fonction de l'objet, les deux ne se renvoient pas la balle à l'infini. Fais glisser la réglette, puis tape un nombre dans le champ et appuie sur Entrée :

# Une glissière et un champ qui se suivent : chacun met l'autre à jour
fonction dessine():
    fond("blanc")
    couleur("noir")
    texte(20, 10, "Rouge :")
    couleur(rgb(valeur_objet("rouge"), 120, 200))
    disque(500, 200, 100)

# la glissière bouge : le champ montre le nouveau nombre
fonction glissée(clef, valeur):
    change_objet("nombre", chaîne(valeur))
    dessine()

# on tape un nombre dans le champ (puis Entrée) : la glissière se place dessus
fonction tapé(clef, valeur):
    n = maximum(0, minimum(255, entier(nombre(valeur))))
    change_objet("rouge", n)
    change_objet("nombre", chaîne(n))
    dessine()

taille_texte(16)
glissière("rouge", 20, 35, 0, 255, 128, glissée)
largeur_saisie(80)
saisie("nombre", 20, 85, tapé)
change_objet("nombre", "128")
dessine()

Un bouton qui change. Le programme peut aussi changer le texte d'un bouton, ou choisir lui-même un bouton radio. Clique cinq fois sur le bouton :

# Le programme change le texte d'un bouton, et choisit lui-même un bouton radio
compte = 0

fonction clic(clef, texte):
    compte += 1
    change_objet("compteur", f"Cliqué {compte} fois")   # le texte du bouton change
    si compte == 5:
        change_objet("moyen", Vrai)                      # le programme choisit « Moyen »
        affiche("Cinq clics : tu passes au niveau moyen")

fonction niveau(groupe, clef):
    affiche("Niveau choisi :", clef)

taille_texte(16)
bouton("compteur", 20, 20, "Clique-moi", clic)
bouton_radio("facile", "niveau", 20, 80, "Facile", niveau)
bouton_radio("moyen", "niveau", 20, 110, "Moyen", niveau)
bouton_radio("difficile", "niveau", 20, 140, "Difficile", niveau)
change_objet("facile", Vrai)

Dessiner en faisant glisser la souris

quand_glisse(f) appelle ta fonction f(x, y) quand tu déplaces la souris en gardant le bouton appuyé (ou ton doigt posé, sur une tablette).

fonction peint(x, y):
    couleur("violet")
    disque(x, y, 6)

quand_glisse(peint)    # appuie, et fais glisser la souris sur le canevas

Ouvre l'exemple 13. Dessiner à la souris pour un vrai petit logiciel de dessin.

🖼️ Images et sons

Ton programme peut aussi montrer des images et jouer des sons. Il faut d'abord les charger. Le plus simple est de mettre tes images et tes sons dans les répertoires images et sons de ton projet (voir Ton projet) : tu donnes alors simplement leur nom, charge_image("chat.png"). Tu peux aussi utiliser les fichiers de la Pythonerie, avec leur chemin (exemples/médias/étoile.svg), ou une adresse Internet qui commence par https://.

Le chargement te donne un numéro. Range-le dans une boîte : c'est grâce à lui que tu retrouves ton image ou ton son.

étoile = charge_image("exemples/médias/étoile.svg")
ding = charge_son("exemples/médias/ding.wav")

fond("bleu marine")
place_image(étoile, 100, 100)            # le coin en haut à gauche est en (100, 100)
place_image(étoile, 300, 100, 200, 200)  # en plus grand : 200 de large, 200 de haut
joue_son(ding)

📄 Lire et écrire un fichier

écrit_fichier(nom, texte) enregistre ton texte dans un fichier, qui arrive dans ton dossier Téléchargements. Donne-lui un simple nom, sans répertoire : "scores" devient scores.txt.

lit_fichier(f) lit tout le texte d'un fichier de ton ordinateur. Pour protéger ton ordinateur, la Pythonerie n'a pas le droit d'y lire ce qu'elle veut : c'est toi qui choisis le fichier, dans une fenêtre. Comme pour une question, le programme n'attend pas : quand tu as choisi le fichier, la Pythonerie appelle la fonction f avec son texte (sa fonction de rappel, voir Poser une question).

# 1. On écrit un fichier : il arrive dans Téléchargements
écrit_fichier("courses", "pommes\npain\nfromage")

# 2. On le relit : choisis courses.txt dans Téléchargements
fonction liste(texte):
    pour article dans texte.découpe("\n"):
        affiche("Il faut acheter :", article)

lit_fichier(liste)

Si tu fermes la fenêtre sans choisir de fichier, la fonction n'est pas appelée. lit_fichier(f, a) appelle f(texte, a).

📚 Le matériel de ton enseignant

Au-dessus des Exemples, la liste 📚 Matériels contient ce que ton enseignant a préparé pour la classe. Un clic sur un projet (son icône est une petite boîte) l'ouvre à la place de ton projet : tu as tout de suite ses programmes, ses images, ses sons et ses données. Ton projet d'avant n'est pas perdu : il t'attend dans la liste Mes projets. Si tu as déjà ouvert ce projet des Matériels, la Pythonerie te propose de retrouver le tien, avec tes changements. Un clic sur un programme seul en crée une copie, comme pour un exemple.

Essaie le projet Le quiz des capitales : ouvre le programme Quiz et exécute-le. Et pour jouer, ouvre le projet Zaxxon : un vaisseau vole au-dessus d'une forteresse, en relief. Le plan de la forteresse est dans le répertoire données, dans forteresse.txt : change ses lettres (C pour un canon, E pour un réservoir, R pour un radar), et invente ta propre forteresse !

▦ Les données de ton projet

Ton programme a parfois besoin de beaucoup de données : une liste de mots, des notes, des pays… Plutôt que de les écrire dans le programme, range-les à côté, dans des onglets. Ces onglets appartiennent à ton projet : tous tes programmes, et ceux qu'ils importent, y trouvent les mêmes données.

• Au-dessus de l'éditeur, clique sur ▦ Données. Le programme laisse la place aux onglets Don0, Don1, Don2… Le bouton s'appelle alors ✎ Code : clique dessus pour revenir à ton programme.
• Tape ou colle tes données dans un onglet, ou clique sur 📂 Charger un fichier… pour y mettre le contenu d'un fichier de ton ordinateur.
• ＋ ajoute un onglet ; − retire celui qui est affiché. L'onglet Don0 reste toujours là : − le vide seulement. Tu t'es trompé ? ↶ fait revenir l'onglet et son contenu (tu peux cliquer plusieurs fois).

Dans ton programme, l'onglet Don0 s'appelle don0, l'onglet Don1 s'appelle don1, et ainsi de suite. C'est une chaîne qui contient tout le texte de l'onglet :

# Dans l'onglet Don0 :
#   pays,capitale
#   France,Paris
#   Canada,Ottawa
pour ligne dans don0.découpe("\n")[1:]:     # la première ligne donne les titres
    pays, capitale = ligne.découpe(",")
    affiche(capitale, "est la capitale du pays", pays)

Ranger et reprendre des données depuis ton programme

range_données("don1", valeur) écrit la valeur dans l'onglet Don1, à la place de ce qu'il contenait. Une liste ou un nombre y est écrit comme affiche l'écrirait. Tu peux aussi créer l'onglet qui vient juste après le dernier : avec Don0, Don1 et Don2, range_données("don3", …) crée Don3. Plus loin ("don5"), c'est une erreur.

carrés = [n * n pour n dans intervalle(1, 11)]
range_données("don0", carrés)
range_données("don1", "Bravo, tu as rangé des données !")
affiche("Regarde les onglets Don0 et Don1 (bouton ▦ Données).")

Les données rangées sont enregistrées avec ton projet. Dans le programme qui tourne, don0 garde sa valeur du départ : il prendra la nouvelle valeur à la prochaine exécution. Si ton programme a écrasé des données par erreur, clique sur ↶, dans les onglets : elles reviennent.

Pour relire un onglet tel qu'il est maintenant, même juste après l'avoir changé, utilise prend_données("don1") : tu obtiens son texte ("" s'il est vide).

range_données("don0", "pomme")
fruit = prend_données("don0")
affiche("Dans Don0, il y a :", fruit)

🗂️ Ton projet

Tous tes programmes, avec tes images, tes sons et tes données, forment ton projet.

Ton projet a un nom, écrit en haut de la liste. Au début, il s'appelle « Sans Nom ». Clique sur ce nom : la liste Mes projets s'ouvre. Elle montre tous tes projets ; clique sur l'un d'eux pour l'ouvrir. Quand tu en as plus de dix, elle montre les dix derniers que tu as ouverts, et la ligne ▸ Les autres projets déroule tous les autres. Tu peux aussi y créer un 🆕 Nouveau projet, ✏️ Renommer celui qui est ouvert, l'📦 Exporter ou le ✖ Fermer : il est alors rangé dans la liste, et tu retrouves un espace vide. La petite corbeille 🗑 supprime un projet.

Quand tu passes à un autre projet, celui que tu quittes est gardé tout seul dans la liste, avec ses derniers changements. La Pythonerie ne te pose qu'une question : si ton projet s'appelle encore « Sans Nom », elle te propose de lui donner un nom, pour le garder. Dans le menu ☰, ↶ Revenir au projet précédent rouvre le projet que tu viens de quitter.

• ＋ Nouveau crée un nouveau programme.
• Le bouton avec un dossier crée un répertoire, comme un tiroir pour ranger tes programmes.
• Pour mettre un programme dans un répertoire, fais-le glisser dessus avec la souris.
• Pour recopier un programme, une image, un son ou des données dans un autre projet, clique sur sa petite icône ⧉ Copier. Ouvre l'autre projet, puis clique sur Coller, dans le bandeau 📋 au-dessus de la liste.
• Quand la souris passe sur un programme, quatre petits boutons apparaissent : ⧉ pour le copier, ✏️ pour le renommer, ⬆️ pour l'enregistrer sur ton ordinateur, 🗑️ pour le supprimer.
• Pour supprimer plusieurs programmes à la fois, choisis-les : garde la touche Cmd (ou Ctrl) appuyée et clique sur chacun d'eux, ou clique sur le premier, puis garde la touche Maj appuyée et clique sur le dernier. Clique ensuite sur 🗑️ Supprimer dans le bandeau qui apparaît, ou appuie sur la touche Suppr.
• Le bouton ☰ propose d'autres actions : copier un programme, importer des fichiers.

🖼️ Les images, les sons et les données du projet

En haut de la liste, trois répertoires bleus attendent tes fichiers : images, sons et données. Fais-y glisser des fichiers depuis ton ordinateur, ou clique sur le petit ＋ du répertoire. Un clic sur un fichier te montre l'image, joue le son ou affiche le début des données.

Dans ton programme, tu n'as besoin que du nom du fichier :

chat = charge_image("chat.png")        # dans le répertoire images
miaou = charge_son("miaou.wav")        # dans le répertoire sons
notes = charge_données("notes.csv")    # dans le répertoire données
place_image(chat, 100, 100)
joue_son(miaou)

🧩 Un programme qui en utilise un autre : importe

Un programme peut se servir des fonctions d'un autre programme de ton projet. Écris, sur une ligne à part, importe "outils" : tout ce que le programme outils définit devient disponible. Si le programme est rangé dans un répertoire, donne son chemin : importe "jeux/outils".

# Le programme « outils »
fonction double(n):
    retourne n * 2

# Un autre programme du projet
importe "outils"
affiche(double(21))       # affiche 42

👤 Dire qui tu es

Au départ, la Pythonerie est en mode Utilisateur unique : le bouton 👤, en haut à droite, affiche Unique et tu n'as pas besoin de dire qui tu es. C'est pratique sur ton ordinateur à toi.

Si plusieurs élèves se servent du même ordinateur, ouvre le menu ☰ et décoche ☑ Utilisateur unique. Chaque élève doit alors taper son nom. Si la case est grisée, c'est que ton école a choisi le mode plusieurs élèves pour tout le monde. Dans ce cas, la Pythonerie est vide chaque fois que tu l'ouvres : pense à exporter ton projet avant de partir !

Le bouton 👤 montre ton nom. Au début, il affiche inconnu. Clique dessus et tape ton nom (ou l'identifiant que t'a donné ton enseignant). Il faut l'avoir tapé pour exécuter un programme : sinon, la Pythonerie te le demande.

Quand tu as fini, clique de nouveau sur 👤 pour te déconnecter. Ton projet rejoint ta liste Mes projets, et l'écran est vidé pour l'élève suivant, qui ne voit que ses propres projets. La prochaine fois, tape le même nom : tu retrouves tous tes projets. Ils restent sur cet ordinateur : pour les emporter ailleurs, exporte-les.

📦 Exporter et charger ton projet

Ton projet peut tenir dans un seul fichier, avec tout ce qu'il contient : programmes, répertoires, images, sons et données. Tu peux le donner à un ami, à ton enseignant, ou le garder pour continuer sur un autre ordinateur.

• Dans le menu ☰, choisis 📦 Exporter le projet. Le fichier s'appelle par exemple Mon_jardin_2026_10_08_14_30.zip : le nom du projet, puis l'année, le mois, le jour, l'heure et la minute. Si plusieurs élèves partagent l'ordinateur, ton nom s'ajoute après celui du projet : Mon_jardin_Léa_2026_10_08_14_30.zip. C'est un fichier zip : une boîte qui contient tes programmes, tes onglets de données, tes images, tes sons et tes données. Si ton projet s'appelle encore « Sans Nom », la Pythonerie te demande d'abord de lui en donner un. Tu le trouves dans le dossier Téléchargements. Dans certaines classes, une copie est aussi envoyée à ton enseignant : la Pythonerie te le dit dans la console.
• Pour l'envoyer par courriel, choisis plutôt ✉️ Exporter pour un courriel (.json) : beaucoup de messageries refusent les fichiers zip, mais pas un fichier texte. Le fichier .json contient la même chose (il est juste un peu plus gros) et s'ouvre de la même façon.
• Encore plus simple : le bouton 📤 à côté du nom de ton projet ouvre le partage de ta tablette ou de ton ordinateur (Mail, Messages, AirDrop…), avec ton projet déjà joint. Celui qui le reçoit l'ouvre avec 📥 Charger un projet….
• Pour ouvrir un projet exporté, choisis 📥 Charger un projet…. Il prend la place de ton projet en cours, qui t'attend dans la liste Mes projets.
• Claude (ou ton enseignant) t'a préparé un projet écrit en texte, qui commence par { "format": "projet-pythonerie" ? Copie-le, puis choisis 📋 Coller un projet (JSON)… dans le menu ☰, colle-le et clique sur Charger le projet.
• Tu t'es trompé ? Dans le menu ☰, choisis ↶ Revenir au projet précédent : ton projet d'avant revient.
• Pour emporter tous tes projets d'un coup, choisis 🗄️ Archiver tous mes projets : ils partent ensemble dans un seul fichier. Sur un autre ordinateur, 🗄️ Charger une archive… les remet dans ta liste. Si tu as déjà un projet du même nom, la Pythonerie te demande lequel garder : le tien, celui de l'archive, ou les deux.

🌐 Créer une application Web

Ton jeu est prêt et tu veux le montrer à tout le monde, même à quelqu'un qui ne connaît pas la Pythonerie ? Dans le menu ☰ (ou sous le nom du projet), choisis 🌐 Créer une application Web…. Si ton projet a plusieurs programmes, la Pythonerie te demande lequel est le programme principal : celui qui se lance. Les programmes qu'il importe, tes images, tes sons et tes données partent avec lui.

Tu reçois un fichier comme Mon_jeu_application_web.zip, dans le dossier Téléchargements. Une fois décompressé, c'est un petit site : une page avec ton canevas, un bouton ▶ Lancer, et la console si ton programme y écrit ou pose des questions. Il n'y a ni éditeur ni code à voir : seulement ton programme qui tourne.

🔒 Tes programmes restent chez toi

La Pythonerie fonctionne entièrement dans ton navigateur. Une fois la page ouverte, rien ne part sur Internet : tes programmes et ton nom restent sur l'ordinateur. Personne d'autre ne les voit, sauf si tu donnes toi-même ton projet à quelqu'un.

Il n'y a pas de compte à créer, pas de publicité et pas de cookie qui te suit.

💡 Astuces

• Ctrl + Entrée exécute le programme sans prendre la souris.
• Quand tu commences à taper un mot, la Pythonerie te propose la suite. Appuie sur Entrée pour la choisir.
• Après une ligne qui se termine par :, la touche Entrée décale tout seul la ligne suivante.
• La liste 📚 Matériels, s'il y en a une, contient ce que ton enseignant a préparé pour toi.
• La liste 🧪 Exemples, à gauche, contient des idées de programmes. Chaque exemple est un projet : un clic l'ouvre dans un projet à son nom (« Casse-briques »), que tu peux changer comme tu veux, et ton projet d'avant t'attend dans Mes projets. Un exemple n'entre pas dans Mes projets : pour garder tes changements, renomme-le (✏️ Renommer le projet). Si tu le quittes après l'avoir changé, la Pythonerie te propose de lui donner un nom. Un nouveau clic sur un exemple repart toujours de l'original, mais ton meilleur score est gardé.
• Le bouton ⛶ Plein écran, au-dessus du canevas, l'agrandit à tout l'écran : c'est parfait pour jouer au casse-briques ! ▤ Console fait venir la console sous le canevas (et la renvoie), ▶ Exécuter lance ton programme et devient ■ Arrêter tant qu'il tourne, et ✕ Quitter le plein écran (ou la touche Échap) te ramène à l'affichage normal. Dans ton programme, affiche_console() fait de même que ▤ Console, et cache_console() la renvoie.
• Le bouton 🌓, en haut, passe la Pythonerie en couleurs sombres.

🙏 Crédits

La Pythonerie a été créée par Claude Roux. Il a aussi inventé LispE, le langage dans lequel tes programmes sont traduits avant d'être exécutés, directement dans ton navigateur.

Elle utilise aussi le travail d'autres personnes, qui le partagent librement : l'éditeur de code CodeMirror, la bibliothèque three.js pour la 3D, les polices Inter et JetBrains Mono, et des images de la NASA, de Solar System Scope et de Wikimedia Commons dans les matériels. Merci à eux !

📖 Glossaire : tous les mots de la Pythonerie

Voici tous les mots que la Pythonerie connaît, rangés par thème. Tape un mot pour le chercher :

couleur("rouge")
disque(50, 50, 40)
p = pixels(0, 0, 100, 100)
pour i dans intervalle(0, longueur(p), 4):
    gris = (p[i] + p[i + 1] + p[i + 2]) / 3
    p[i] = gris
    p[i + 1] = gris
    p[i + 2] = gris
pose_pixels(120, 0, 100, 100, p)