vault backup: 2026-10-15 00:28:56

docs/presentations/ID01 - Lire, remplir et signer ses PDF.md

@@ -0,0 +1,110 @@
+**Format** : Court (20 min)
+
+**Objectif :** ne plus imprimer un formulaire pour le signer puis le scanner.
+
+**Déroulé**
+
+1. Le lecteur de Linux Mint (Xreader) : lire, chercher, surligner.
+2. Okular : annoter et remplir un formulaire.
+3. Xournal++ : apposer une signature manuscrite.
+4. PDF Arranger : fusionner, découper, réordonner des pages.
+5. Exporter en PDF depuis LibreOffice, réduire le poids pour un envoi par mail.
+
+**Démo :** remplir et signer un vrai formulaire, le fusionner avec une pièce justificative.
+
+--
+
+Voilà ce que nous voulons faire : Un dossier d’inscription à envoyer par mail. C'est un formulaire à remplir et signer, une pièce justificative à joindre, le tout en un seul PDF léger. Chaque outil résout une étape.
+
+### Avant la séance
+
+**Fichiers à préparer**
+
+- Un formulaire PDF avec champs modifiables (un CERFA convient).
+- Un formulaire sans champs, par exemple un document scanné.
+- Un justificatif en image (photo d’une facture fictive).
+- Une signature sur papier blanc, photographiée et enregistrée en PNG.
+
+**Installation** (Xreader et LibreOffice sont déjà dans Linux Mint) :
+
+```
+sudo apt install okular xournalpp pdfarranger
+```
+
+Les trois sont aussi dans la Logithèque, à utiliser si vous ne vous sentez pas à l'aise avec  le terminal.
+
+### 1. Xreader, le lecteur déjà installé
+
+- Ouvrir le formulaire par double-clic.
+- Le panneau latéral : vignettes des pages et sommaire.
+- Chercher un mot avec Ctrl+F.
+- Surligner un passage et ajouter une note depuis le panneau des annotations.
+- Remplir directement un champ du formulaire.
+
+**À noter :** pour lire et pour un formulaire simple, il n’y a rien à installer.
+
+**Piège :** utiliser « Enregistrer une copie », sinon les annotations et la saisie sont perdues à la fermeture.
+
+### 2. Okular, pour annoter et remplir
+
+- La barre d’annotations (F6) : surligneur, note, trait à main levée.
+- Le bouton « Afficher les formulaires », puis la saisie des champs et des cases à cocher.
+- L’outil « machine à écrire » : il permet d’écrire sur un PDF qui n’a pas de champs, cas très fréquent avec les documents scannés.
+- Enregistrer avec Ctrl+S, puis rouvrir le fichier dans Xreader pour prouver que le texte est bien dedans.
+
+**À retenir :** Okular vient de l’environnement KDE mais fonctionne très bien sous Mint. C’est l’outil à retenir si l’on ne devait en installer qu’un.
+
+**Piège :** un PDF protégé peut refuser la saisie. Dans ce cas, passer à Xournal++.
+
+### 3. Xournal++, pour signer
+
+- Fichier > Annoter un PDF, puis ouvrir le formulaire rempli.
+- Méthode 1 : signer au stylet ou à la souris avec l’outil stylo (résultat médiocre à la souris, le montrer avec humour).
+- Méthode 2, la bonne : insérer l’image de sa signature, la redimensionner et la placer.
+- Ajouter la date avec l’outil texte.
+- Fichier > Exporter en PDF.
+
+**À noter :** une signature collée en image est acceptée pour beaucoup de démarches courantes, mais ce n’est pas une signature électronique qualifiée. Pour un acte important, l’organisme impose généralement son propre service.
+
+**Piège :** « Enregistrer » produit un fichier .xopp, illisible pour le destinataire. Il faut exporter en PDF. C’est l’erreur numéro un.
+
+**Conseil de sécurité :** ranger le PNG de sa signature dans un dossier discret, et ne pas le laisser traîner sur une clé USB.
+
+### 4. PDF Arranger, pour assembler
+
+- Glisser le formulaire signé et le justificatif dans la fenêtre.
+- Réordonner les pages à la souris.
+- Faire pivoter une page scannée de travers.
+- Supprimer une page blanche.
+- Extraire une seule page d’un long document : sélectionner, puis exporter la sélection.
+- Enregistrer sous un nouveau nom.
+
+**À noter :** le logiciel accepte aussi les images, donc une photo de justificatif devient une page PDF sans étape intermédiaire.
+
+**Piège :** enregistrer sous un nouveau nom pour ne pas écraser l’original.
+
+### 5. Exporter et alléger
+
+- Dans LibreOffice Writer : Fichier > Exporter vers PDF.
+- Dans les options : compression JPEG et réduction de la résolution des images à 150 DPI. Comparer le poids avant et après dans le gestionnaire de fichiers.
+- Mentionner l’option PDF hybride, qui embarque le fichier d’origine et permet de le remodifier plus tard.
+
+**Pour un PDF déjà existant et trop lourd**, typiquement un scan, une commande suffit :
+
+```
+gs -sDEVICE=pdfwrite -dPDFSETTINGS=/ebook -dNOPAUSE -dBATCH -sOutputFile=leger.pdf lourd.pdf
+```
+
+**À noter :** les sites de compression en ligne fonctionnent, mais on y envoie sa pièce d’identité ou son avis d’imposition à un inconnu. Tout ce qui a été montré ce soir reste sur l’ordinateur.
+
+### Conclusion
+
+Rappeler le parcours : remplir (Okular), signer (Xournal++), assembler (PDF Arranger), alléger, envoyer. Pas d’imprimante, pas de scanner, pas de service en ligne.
+
+|Je veux|J’utilise|
+|---|---|
+|Lire, chercher, surligner|Xreader|
+|Remplir un formulaire, écrire sur un PDF|Okular|
+|Signer|Xournal++|
+|Fusionner, découper, pivoter|PDF Arranger|
+|Créer un PDF léger|LibreOffice|

docs/presentations/ID02 - Ranger et sauvegarder ses documents.md

@@ -0,0 +1,16 @@
+**Format** : Court (20 min)
+
+**Objectif :** savoir quoi sauvegarder et où, avant de parler d’outil.
+
+**Déroulé**
+
+1. Où sont mes fichiers : le dossier personnel, Documents, Images (rappel de la présentation existante).
+2. Ce qui est irremplaçable (photos, papiers) et ce qui ne l’est pas (logiciels, système).
+3. La règle 3-2-1 expliquée simplement : trois copies, deux supports, une ailleurs.
+4. Choisir son support : disque externe, clé USB, [[NAS]], [[Nextcloud]].
+5. Synchronisation et sauvegarde ne sont pas la même chose : une suppression par erreur se propage.
+
+**Démo :** copier son dossier Documents sur un disque externe, puis vérifier que la copie s’ouvre.
+
+**Remarque :** « Les sauvegardes » figure déjà dans les présentations passées et un guide existe sur le wiki. Cette séance peut en être la version actualisée, centrée sur les documents personnels.
+[sauvegardes](../guides/sauvegardes.md)

docs/presentations/ID03 - Les outils de sauvegarde de Linux Mint.md

@@ -0,0 +1,16 @@
+**Format** : Long (45 min)
+
+**Objectif :** que chacun reparte avec une sauvegarde configurée sur sa machine.
+
+**Déroulé**
+
+1. Deux outils, deux rôles : Timeshift pour le système, l’Outil de sauvegarde pour les fichiers personnels.
+2. Timeshift : choisir le disque, la fréquence, le nombre d’instantanés conservés, puis restaurer après une mise à jour ratée.
+3. Outil de sauvegarde : sauvegarder son dossier personnel, exclure des dossiers, restaurer.
+4. Sauvegarder la liste de ses logiciels, pratique pour une réinstallation.
+5. Pour aller plus loin : Déjà Dup ou Pika Backup, avec planification et chiffrement.
+6. Tester une restauration, l’étape que tout le monde oublie.
+
+**Démo :** supprimer volontairement un fichier, puis le restaurer.
+
+**À prévoir :** demander aux participants d’apporter leur portable et un disque externe.

docs/presentations/ID04 - Nextcloud au quotidien.md

@@ -0,0 +1,18 @@
+
+**Format :** long, 45 min
+
+**Objectif :** utiliser [[Nextcloud]] côté utilisateur, sans parler d’installation de serveur.
+
+**Déroulé**
+
+1. À quoi ça sert : ses fichiers accessibles partout, sans Google Drive ni OneDrive.
+2. L’interface web : déposer, ranger, retrouver une version précédente, corbeille.
+3. Le client de synchronisation sous Linux Mint : choisir les dossiers.
+4. L’application mobile : envoi automatique des photos.
+5. Partager : lien public, mot de passe, date d’expiration.
+6. Agenda et contacts, reliés à Thunderbird.
+7. Les limites : quota, et toujours pas une sauvegarde à lui seul.
+
+**Démo :** partager un dossier avec la salle par un code QR, chacun y dépose une photo.
+
+**Atout :** le portail membres d’Alpinux donne déjà accès à un Nextcloud, donc les adhérents peuvent pratiquer tout de suite, et c’est un argument d’adhésion. [alpinux](https://alpinux.org/)

docs/presentations/Pix orientée Libre/0 - Compétences PIX.md

@@ -0,0 +1,44 @@
+Le référentiel Pix (aligné sur le CRCN, le Cadre de référence des compétences numériques) compte 16 compétences rassemblées en 5 grands domaines, décliné du cadre commun de référence européen DIGCOMP 2.1. Les voici :
+
+**1. Information et données**
+
+- 1.1 [[Mener une recherche et une veille d'information]]
+- 1.2 [[Gérer des données]]
+- 1.3 [[Traiter des données]]
+
+**2. Communication et collaboration**
+
+- 2.1 [[Interagir]]
+- 2.2 [[Partager et publier]]
+- 2.3 [[Collaborer]]
+- 2.4 [[S'insérer dans le monde numérique]]
+
+**3. Création de contenu**
+
+- 3.1 [[Développer des documents textuels]]
+- 3.2 [[Développer des documents multimédia]]
+- 3.3 [[Adapter les documents à leur finalité]]
+- 3.4 [[Programmer]]
+
+**4. Protection et sécurité**
+
+- 4.1 [[Sécuriser l'environnement numérique]]
+- 4.2 [[Protéger les données personnelles et la vie privée]]
+- 4.3 [[Protéger la santé, le bien-être et l'environnement]]
+
+**5. Environnement numérique**
+
+- 5.1 [[Résoudre des problèmes techniques]]
+- 5.2 [[Construire un environnement numérique]]
+
+Quelques repères utiles : le cadre prévoit 8 niveaux de maîtrise progressive, les niveaux 1 à 5 concernant les élèves de collège et de lycée. Chaque compétence est décomposée en sous-compétences, elles-mêmes déclinées en acquis par niveau, et côté score, une compétence validée au niveau le plus élevé « rapporte » 64 Pix (8 Pix par niveau). Enfin, la certification doit être renouvelée tous les 3 ans.
+
+Le détail de chaque compétence est consultable sur pix.fr/competences.
+
+Sources :
+
+- [France Compétences – Certificat Pix](https://www.francecompetences.fr/recherche/rs/3807)
+- [France Compétences – fiche Pix](https://certifpro.francecompetences.fr/api/fiches/downloadAncFormat/18995)
+- [Collège Alfred Kastler – Parcours Pix 3e](https://alfred-kastler.college.ac-normandie.fr/IMG/pdf/parcours_de_formation_pix_3e.pdf)
+- [Collège Anna Marly – Pix et continuité pédagogique](https://www.college-anna-marly-brest.ac-rennes.fr/sites/college-anna-marly-brest.ac-rennes.fr/IMG/pdf/pix_et_continuite_pedagogique.pdf)
+

docs/presentations/Pix orientée Libre/Adapter les documents à leur finalité.md

@@ -0,0 +1,74 @@
+## 3.3 Adapter les documents à leur finalité
+
+**Ce que recouvre la compétence** : transformer un document selon son usage (impression, mise en ligne, projection, mises à jour fréquentes, diffusion sur plusieurs supports) et maîtriser les licences qui encadrent sa réutilisation. Thématiques Pix : choix et conversion de formats, poids et qualité des fichiers, interopérabilité, accessibilité, licences.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : enregistrer un document dans un autre format, exporter en PDF.
+- **N3** : choisir le format selon l'usage (modifiable ou figé), réduire le poids d'une image avant envoi.
+- **N4-N5** : préparer un document pour l'impression ou la projection, appliquer une licence à sa production, respecter celles des ressources réutilisées.
+- **N6+** : organiser une production multisupport à partir d'une source unique, automatiser les conversions, gérer la compatibilité des licences.
+
+### Version Linux et libre
+
+**Choisir le bon format selon l'usage**
+
+- À modifier : ODT, ODS, ODP, Markdown
+- À diffuser figé ou imprimer : PDF ; à archiver : PDF/A
+- Pour le web : HTML ; pour une liseuse : EPUB
+- Images : PNG (schémas), JPEG ou WebP (photos), SVG (vectoriel)
+- Audio et vidéo : Opus, FLAC, WebM (formats ouverts) ; MP3 et MP4 pour la compatibilité
+
+**Convertir**
+
+- LibreOffice en ligne de commande : `soffice --headless --convert-to pdf *.odt` pour tout un dossier
+- **Pandoc** : une source Markdown, plusieurs sorties (principe de la diffusion multicanale)
+- Images : **ImageMagick**, Converseen (par lots), Switcheroo (GNOME)
+- Audio et vidéo : **FFmpeg**, HandBrake
+
+**Alléger et optimiser**
+
+- Compression avec ou sans perte : comprendre le compromis
+- Images : Curtail, ou `magick photo.jpg -resize 1200x photo-web.jpg`
+- PDF trop lourd : Ghostscript, réglages d'export de LibreOffice
+- Assembler, découper, réordonner des PDF : PDF Arranger, `qpdf`
+
+**Préparer pour l'impression**
+
+- Résolution (300 ppp), marges, fonds perdus
+- Couleurs CMJN avec Scribus
+- Impression en livret depuis LibreOffice, gestion des imprimantes avec CUPS
+
+**Préparer pour la projection**
+
+- Format 16:9, gros caractères, contrastes forts
+- PDF avec polices incorporées pour éviter les surprises sur un autre poste
+
+**Documents mis à jour souvent**
+
+- Garder la source modifiable, versionner (lien 2.3)
+- Champs automatiques (dates, numéros), modèles, publipostage
+
+**Accessibilité**
+
+- PDF balisé, texte alternatif
+- **OCRmyPDF** : rendre un PDF scanné lisible et cherchable
+
+**Avant diffusion**
+
+- Retirer métadonnées et traces de révisions : option de LibreOffice pour supprimer les informations personnelles à l'enregistrement, **mat2**
+
+**Licences**
+
+- Creative Commons : choisir, afficher la mention dans le document et ses propriétés
+- Compatibilité : on ne peut pas mélanger librement BY-SA et BY-NC dans une même œuvre
+- **CC0** pour le domaine public, **Licence Ouverte (Etalab)** pour les données publiques, **GPL** pour le code
+- Vérifier la licence de chaque ressource réutilisée et la créditer
+
+### Idées d'activités
+
+- Partir d'un même contenu et produire trois versions : une affiche imprimable, une page web légère, un diaporama à projeter
+- Convertir tout un dossier de documents en PDF en une seule commande
+- Défi poids : envoyer un document illustré de 25 Mo en moins de 2 Mo sans perte visible de qualité
+- Rendre un PDF scanné accessible avec OCRmyPDF, puis tester avec un lecteur d'écran (Orca)
+- Construire un document à partir de ressources sous différentes licences et vérifier si la combinaison est autorisée

docs/presentations/Pix orientée Libre/Collaborer.md

@@ -0,0 +1,65 @@
+## 2.3 Collaborer
+
+**Ce que recouvre la compétence** : travailler à plusieurs pour réaliser un projet, coproduire des documents, des données ou des connaissances, et apprendre ensemble. Thématiques Pix : outils d'édition partagée, suivi des modifications et gestion de versions, droits d'accès, organisation du travail en groupe, production de communs.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : modifier un document partagé, laisser un commentaire.
+- **N3** : utiliser le suivi des modifications et l'historique des versions, respecter le travail des autres.
+- **N4-N5** : organiser un projet de groupe (répartition des tâches, échéances), gérer les droits d'accès d'un espace partagé.
+- **N6+** : choisir et mettre en place un environnement collaboratif adapté, gérer les versions et les conflits, coordonner une production à grande échelle.
+
+### Version Linux et libre
+
+**Édition simultanée**
+
+- **CryptPad** : texte, tableur, présentation, kanban, formulaires, tableau blanc, le tout chiffré de bout en bout
+- **Etherpad** : texte en temps réel avec une couleur par auteur, très lisible pour voir qui a écrit quoi
+- **HedgeDoc** : Markdown collaboratif
+- Nextcloud avec **Collabora Online** ou **OnlyOffice** : bureautique complète dans le navigateur
+
+**Travailler hors ligne, à plusieurs**
+
+- LibreOffice : suivi des modifications (accepter/refuser), commentaires, comparaison de deux versions d'un document
+
+**Gestion de versions**
+
+- Historique des versions dans Nextcloud et CryptPad : revenir en arrière
+- **Git** : `clone`, `commit`, `pull`, `push`, branches, résolution de conflits
+- Forges libres : **Codeberg**, GitLab, Forgejo (auto-hébergeable)
+- Tickets (issues) et demandes de fusion : le modèle de collaboration du logiciel libre
+
+**Organisation et suivi de projet**
+
+- Kanban : Nextcloud Deck, Kanboard, Wekan, Vikunja
+- Gestion de projet plus poussée : OpenProject, Taiga
+- Tableaux blancs : Excalidraw, draw.io, tableau blanc de BigBlueButton
+
+**Bases de connaissances**
+
+- Wikis d'équipe : BookStack, Wiki.js, DokuWiki
+
+**Espaces de travail complets**
+
+- **Nextcloud** : fichiers, agenda, discussions, tâches au même endroit
+- Framaspace (Nextcloud pour associations et collectifs)
+- apps.education.fr pour les personnels de l'Éducation nationale
+- Discussions d'équipe : Matrix/Element, Mattermost
+
+**Droits d'accès**
+
+- Lecture, commentaire, édition, administration : qui peut faire quoi
+- Liens publics vs accès nominatif
+
+**Méthodes de travail**
+
+- Définir des rôles, des conventions de nommage, un calendrier
+- Décider ensemble des règles (gouvernance), comme dans les projets libres
+
+### Idées d'activités
+
+- Rédaction à plusieurs sur Etherpad, puis analyse des couleurs : la contribution est-elle équilibrée ?
+- Relecture croisée d'un texte dans LibreOffice avec suivi des modifications
+- Gérer un projet de groupe de bout en bout avec un tableau Deck ou Kanboard
+- Premier pas avec Git sur Codeberg : chacun modifie un fichier, on provoque puis on résout un conflit
+- Observer un vrai projet libre (tickets, discussions, contributions) pour comprendre comment des milliers de personnes collaborent sans se connaître

docs/presentations/Pix orientée Libre/Construire un environnement numérique.md

@@ -0,0 +1,79 @@
+## 5.2 Construire un environnement numérique
+
+**Ce que recouvre la compétence** : installer, configurer et enrichir un environnement (matériel, système, logiciels, services) adapté à ses activités, à son contexte et à ses valeurs. C'est la compétence où le choix de Linux et du libre devient lui-même l'objet d'apprentissage. Thématiques Pix : composants matériels, systèmes d'exploitation, installation de logiciels, configuration et personnalisation, périphériques et réseau, choix de services.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : allumer et prendre en main un appareil, connecter un périphérique, personnaliser le fond d'écran ou la langue.
+- **N3** : installer et désinstaller une application, connecter un appareil au réseau, choisir ses applications par défaut.
+- **N4-N5** : configurer un système (comptes, partage, périphériques), choisir des logiciels et services selon des critères explicites.
+- **N6+** : installer un système d'exploitation, concevoir un environnement complet pour un usage ou un groupe, auto-héberger des services.
+
+### Version Linux et libre
+
+**Comprendre les couches**
+
+- Matériel (processeur, mémoire, stockage, carte graphique), micrologiciel UEFI
+- Noyau Linux, pilotes, système GNU, environnement de bureau, applications
+- Une même base, de nombreuses combinaisons : c'est ce qui rend les choix visibles et compréhensibles
+
+**Choisir sa distribution et son bureau**
+
+- Pour débuter : **Linux Mint**, Ubuntu, Zorin OS
+- Stables et communautaires : **Debian**, Fedora, openSUSE
+- Pour apprendre en profondeur : Arch Linux
+- Contextes particuliers : **PrimTux** (écoles primaires, projet français), Emmabuntüs (réemploi)
+- Environnements de bureau : GNOME, KDE Plasma, Xfce, Cinnamon, MATE, LXQt (du plus riche au plus léger)
+
+**Installer le système**
+
+- Tester sans rien modifier grâce au mode live
+- Créer une clé d'installation : Impression d'image disque (GNOME), balenaEtcher, Ventoy
+- Choix d'installation : remplacer l'ancien système ou cohabiter (double démarrage), partitionnement, chiffrement LUKS (lien 4.1), Secure Boot
+- S'entraîner d'abord en machine virtuelle avec GNOME Boxes
+
+**Installer des logiciels**
+
+- Gestionnaire de paquets : `apt`, `dnf`, `pacman`
+- Logithèques graphiques : Logiciels (GNOME), Discover (KDE)
+- **Flatpak et Flathub**, Snap, AppImage : comprendre leurs différences, avantages et limites
+- Règle d'or : privilégier les sources officielles plutôt que des fichiers téléchargés au hasard
+
+**Configurer et personnaliser**
+
+- Comptes utilisateurs et groupes, droits d'administration
+- Langue, disposition du clavier, raccourcis, applications par défaut, lancement au démarrage
+- Extensions GNOME, widgets KDE, thèmes
+- Les réglages sont stockés dans `~/.config` : sauvegarder et transporter son environnement (_dotfiles_)
+
+**Périphériques et réseau**
+
+- Imprimantes et scanners (lien 5.1)
+- Partage de dossiers en réseau local avec Samba
+- **KDE Connect** ou GSConnect (GNOME) : relier son téléphone à son ordinateur (fichiers, notifications, presse-papiers)
+
+**Choisir ses services selon ses valeurs**
+
+- Hébergeurs du collectif CHATONS, Framaspace, Nextcloud (lien 1.2 et 2.3)
+- Téléphone : F-Droid, /e/OS (lien 4.2)
+- Critères à expliciter : liberté du logiciel, formats ouverts, vie privée, localisation des données, sobriété, coût
+
+**Auto-héberger**
+
+- **YunoHost** (projet français) : installer Nextcloud, FreshRSS, Wallabag et d'autres en quelques clics sur un serveur ou un Raspberry Pi
+- Pour aller plus loin : conteneurs avec Podman ou Docker
+
+**Penser l'environnement comme un tout**
+
+- Mises à jour, sauvegardes, sécurité : un plan de maintenance (liens 1.2, 4.1, 5.1)
+- Interopérabilité avec les utilisateurs d'autres systèmes : formats ouverts, services web
+- Exemple de déploiement à grande échelle : la Gendarmerie nationale et ses dizaines de milliers de postes sous GendBuntu
+
+### Idées d'activités
+
+- Tester trois distributions en machine virtuelle et justifier son choix selon un profil d'utilisateur donné
+- Installer Linux sur un vrai ordinateur, de la création de la clé à la configuration finale
+- Concevoir un environnement « clé en main » pour un public précis (élève, association, personne âgée) et le documenter
+- Monter un petit serveur YunoHost sur un Raspberry Pi avec deux ou trois services utiles au groupe
+- Relier son téléphone à son PC avec KDE Connect
+- Rédiger une charte de choix numériques pour une classe ou une association, argumentée par des valeurs

docs/presentations/Pix orientée Libre/Développer des documents multimédia.md

@@ -0,0 +1,81 @@
+## 3.2 Développer des documents multimédia
+
+**Ce que recouvre la compétence** : créer ses propres productions mêlant image, son, vidéo ou animation, enrichir un document textuel, ou réaliser une œuvre transformative (remix, détournement). Thématiques Pix : capture et édition d'images, de sons et de vidéos, image matricielle et vectorielle, formats et codecs, montage, droit d'auteur et droit à l'image.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : faire une capture d'écran, recadrer une photo, enregistrer un son.
+- **N3** : retoucher une image, couper et assembler des séquences audio ou vidéo, distinguer image matricielle et vectorielle.
+- **N4-N5** : réaliser un montage complet (titres, transitions, musique, sous-titres), travailler avec des calques, choisir formats et réglages d'export.
+- **N6+** : mener une production multimédia de bout en bout, créer des animations, réaliser des remix en respectant les licences.
+
+### Version Linux et libre
+
+**Notions de base à faire comprendre**
+
+- Pixels (matriciel) vs formes mathématiques (vectoriel) : effet d'un agrandissement
+- Calques, résolution, profondeur de couleur
+- Conteneur (MKV, WebM, MP4) vs codec (AV1, VP9, H.264 pour la vidéo ; Opus, AAC pour le son)
+- Débit, images par seconde, fréquence d'échantillonnage
+
+**Captures**
+
+- Captures d'écran : outil intégré de GNOME (touche Impr. écran), Spectacle (KDE), **Flameshot** pour annoter
+- Enregistrement d'écran : outil intégré de GNOME, Kooha, **OBS Studio** pour des tutoriels plus élaborés
+
+**Image matricielle**
+
+- **GIMP** : retouche, calques, masques
+- **Krita** : dessin et peinture numérique
+- Pinta : simple, pour débuter
+- darktable ou RawTherapee : développement de photos RAW
+
+**Image vectorielle et schémas**
+
+- **Inkscape** : logos, affiches, illustrations, format SVG
+- draw.io, Dia : schémas et organigrammes
+
+**Son**
+
+- **Audacity** : enregistrement, découpe, réduction de bruit, effets (idéal pour un podcast)
+- Ardour : enregistrement multipiste
+- LMMS : composition, MuseScore : partitions
+
+**Vidéo**
+
+- **Kdenlive** : montage complet, le plus abouti
+- Shotcut, OpenShot : plus simples pour démarrer
+- Sous-titres : Aegisub, Gaupol ; transcription automatique hors ligne avec des outils basés sur Whisper (par exemple Speech Note)
+
+**Animation et 3D**
+
+- Pencil2D : animation 2D image par image, accessible aux débutants
+- Synfig Studio : animation 2D vectorielle
+- **Blender** : 3D, animation, et même montage vidéo
+- Sweet Home 3D : aménagement intérieur
+
+**Installation sous Linux**
+
+- **Flathub** pour obtenir les versions récentes de ces logiciels
+- Codecs : certaines distributions demandent d'installer à part les codecs non libres (paquet « restricted extras » sur Ubuntu, par exemple)
+
+**Ressources libres pour enrichir et remixer**
+
+- **Wikimedia Commons**, **Openverse** (moteur de recherche de médias sous Creative Commons)
+- **Freesound** pour les sons, ccMixter et Free Music Archive pour la musique
+- Toujours vérifier la licence : une ressource en ND (pas de modification) ne peut pas être remixée
+
+**Droits**
+
+- Droit à l'image : autorisation des personnes filmées ou photographiées
+- Droit d'auteur, courte citation, exception pédagogique
+- Créditer les ressources utilisées dans le générique
+
+### Idées d'activités
+
+- Comparer l'agrandissement d'un logo en PNG dans GIMP et en SVG dans Inkscape
+- Réaliser un podcast de 3 minutes avec Audacity, avec un générique musical sous licence libre
+- Tourner et monter une courte vidéo dans Kdenlive, sous-titres et crédits compris
+- Enregistrer un tutoriel vidéo avec OBS pour expliquer une manipulation sous Linux
+- Créer un remix à partir de ressources trouvées sur Openverse, en documentant chaque licence
+- Animation image par image avec Pencil2D

docs/presentations/Pix orientée Libre/Développer des documents textuels.md

@@ -0,0 +1,73 @@
+## 3.1 Développer des documents textuels
+
+**Ce que recouvre la compétence** : produire des documents principalement textuels pour communiquer des idées, rendre compte d'un travail ou le valoriser (traitement de texte, présentation, page web, carte mentale). Thématiques Pix : structuration et séparation fond/forme, mise en page, intégration d'illustrations, formats et diffusion, accessibilité, droit d'auteur.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : saisir et mettre en forme un texte simple (gras, taille, alignement), insérer une image.
+- **N3** : structurer un document avec des titres, insérer tableaux et listes, exporter en PDF.
+- **N4-N5** : utiliser les **styles**, générer une table des matières, gérer en-têtes, pieds de page et notes, créer un modèle.
+- **N6+** : séparer complètement fond et forme, automatiser (publipostage, conversion), produire des documents accessibles et interopérables.
+
+### Version Linux et libre
+
+**Traitement de texte : LibreOffice Writer**
+
+- **Styles** de paragraphe, de caractère, de page : le cœur de la compétence
+- Numérotation automatique des titres, table des matières, index, notes de bas de page
+- Ancrage et habillage des images, tableaux, sections en colonnes
+- Modèles (`.ott`), publipostage
+- Export PDF, PDF/A pour l'archivage, PDF balisé pour l'accessibilité
+- **Vérificateur d'accessibilité** intégré
+
+**Correction de la langue**
+
+- **Grammalecte** : correcteur grammatical français libre, pour LibreOffice et Firefox
+
+**Présentations**
+
+- LibreOffice Impress : masques de diapositives, mode présentateur, export PDF
+
+**Écrire en Markdown**
+
+- Éditeurs : Apostrophe (GNOME), Ghostwriter (KDE), Zettlr, ou simplement Kate / Éditeur de texte
+- **Pandoc** : convertir un même texte en ODT, DOCX, PDF, HTML ou EPUB, démonstration parfaite de la séparation fond/forme
+
+**Composition avancée**
+
+- LaTeX avec TeXstudio, pour les documents scientifiques
+- **Typst** : alternative récente, libre, plus simple à apprendre
+- Scribus pour la mise en page de type affiche, journal ou brochure
+
+**Cartes mentales et conceptuelles**
+
+- Freeplane, VYM, Heimer
+
+**Pages web et livres numériques**
+
+- HTML et CSS avec un simple éditeur de texte et le navigateur
+- Sigil pour créer un EPUB, Calibre pour le convertir et le gérer
+
+**Formats et interopérabilité**
+
+- ODF (`.odt`) : format ouvert, normalisé ISO, recommandé par le Référentiel général d'interopérabilité de l'administration
+- Échanges avec des utilisateurs de Word : polices aux métriques compatibles (Carlito pour Calibri, Caladea pour Cambria) pour éviter les décalages de mise en page
+
+**Typographie et polices libres**
+
+- Liberation, DejaVu, Noto
+- **Luciole** : police libre conçue pour les personnes malvoyantes
+- Installer une police dans `~/.local/share/fonts`
+
+**Accessibilité**
+
+- Titres structurés par styles (et non par mise en forme manuelle)
+- Texte alternatif pour les images, contrastes suffisants, écriture FALC (Facile à lire et à comprendre)
+
+### Idées d'activités
+
+- Partir d'un document mis en forme « à la main » et le refaire entièrement avec les styles, puis changer tout son aspect en modifiant un seul style
+- Rédiger un compte rendu en Markdown, puis le convertir avec Pandoc en ODT, PDF et page web
+- Faire passer le vérificateur d'accessibilité sur un document et corriger toutes les alertes
+- Échanger un fichier ODT et DOCX avec un utilisateur de Word et analyser ce qui change
+- Créer un modèle de lettre réutilisable avec publipostage à partir d'un fichier Calc

docs/presentations/Pix orientée Libre/Gérer des données.md

@@ -0,0 +1,75 @@
+## 1.2 Gérer des données
+
+**Ce que recouvre la compétence** : stocker et organiser ses fichiers pour les retrouver, les conserver et y accéder facilement, en local comme en ligne. Les thématiques Pix : fichiers et dossiers, stockage et compression, transfert et synchronisation, recherche et métadonnées, sauvegarde.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : enregistrer un fichier, le retrouver, le nommer et le ranger dans un dossier.
+- **N3** : construire une arborescence cohérente, utiliser un espace de stockage en ligne, compresser/décompresser.
+- **N4-N5** : synchroniser plusieurs appareils, mettre en place des sauvegardes, choisir un format adapté, exploiter les métadonnées.
+- **N6+** : définir une stratégie de stockage et de sauvegarde pour un groupe, gérer les droits d'accès.
+
+### Version Linux et libre
+
+**Comprendre l'arborescence**
+
+- Une seule racine `/`, le dossier personnel `/home/utilisateur`, les supports amovibles dans `/media`
+- Chemins absolus et relatifs, fichiers cachés (commençant par un point)
+- La casse compte : `Rapport.odt` ≠ `rapport.odt`
+- Le type d'un fichier ne dépend pas de son extension : la commande `file` le révèle
+
+**Gestionnaires de fichiers**
+
+- Graphiques : Fichiers (GNOME), Dolphin (KDE), Thunar (XFCE), Nemo
+- Terminal : `ls`, `cd`, `mkdir`, `cp`, `mv`, `rm`, `tree` ; Midnight Commander (`mc`) en intermédiaire
+- Bonnes pratiques de nommage : dates au format `AAAA-MM-JJ`, pas d'espaces ni d'accents si les fichiers circulent
+
+**Retrouver ses fichiers**
+
+- `find`, `locate`, `grep -r` pour chercher dans le contenu
+- Recherche intégrée au bureau : Tracker/LocalSearch (GNOME), Baloo (KDE)
+- Doublons : Czkawka (graphique), `fdupes`
+
+**Métadonnées**
+
+- Étiquettes dans Dolphin, gestion de photothèque avec digiKam
+- Lire : `exiftool` ; nettoyer avant partage : **mat2** (lien direct avec la compétence 4.2 sur la vie privée)
+
+**Compression et archives**
+
+- `tar`, `gzip`, `xz`, `zip`, `7z`
+- Graphiques : Archives (File Roller), Ark
+
+**Supports et systèmes de fichiers**
+
+- Voir l'espace : `df -h`, `du`, `ncdu`, `lsblk`
+- GNOME Disques, GParted pour formater
+- Choisir le bon format : ext4 pour Linux, exFAT pour une clé partagée avec Windows/macOS
+
+**Stockage en ligne et synchronisation**
+
+- **Nextcloud** (auto-hébergé ou chez un CHATON), Seafile
+- **Syncthing** : synchronisation pair à pair, sans serveur central
+- `rsync` en ligne de commande
+- Transfert ponctuel : LocalSend (réseau local), Lufi (partage chiffré temporaire, Framasoft), `scp`/`sftp`, FileZilla
+
+**Sauvegarde**
+
+- Règle 3-2-1 : 3 copies, 2 supports différents, 1 hors site
+- Déjà Dup (simple, intégré à GNOME), Back In Time, BorgBackup avec son interface Vorta, restic
+- Timeshift pour des instantanés du système (à distinguer de la sauvegarde des données personnelles)
+
+**Droits et partage**
+
+- `ls -l`, `chmod`, `chown` : lire et modifier les permissions, comprendre propriétaire/groupe/autres
+
+**Formats ouverts** (pour la conservation à long terme)
+
+- ODF (LibreOffice), CSV, Markdown, PNG, FLAC, PDF/A
+
+### Idées d'activités
+
+- Ranger un dossier « fourre-tout » en arborescence logique, d'abord graphiquement puis en ligne de commande
+- Mettre en place une synchronisation Syncthing entre un PC et un téléphone
+- Retirer les métadonnées GPS d'une photo avec mat2 et vérifier avec exiftool
+- Simuler une panne : sauvegarder avec Déjà Dup, supprimer un fichier, le restaurer

docs/presentations/Pix orientée Libre/Interagir.md

@@ -0,0 +1,55 @@
+## 2.1 Interagir
+
+**Ce que recouvre la compétence** : échanger avec des personnes ou de petits groupes, de façon ponctuelle ou régulière, dans un cadre privé ou professionnel, par courriel, messagerie instantanée ou visioconférence. Thématiques Pix : protocoles et services de communication, usages adaptés au contexte, savoir-vivre en ligne (nétiquette), confidentialité, prévention du cyberharcèlement.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : envoyer et recevoir un message, répondre, joindre un fichier.
+- **N3** : choisir l'outil adapté à la situation, utiliser À / Cc / Cci à bon escient, adopter un ton approprié.
+- **N4-N5** : organiser des échanges de groupe, animer une visioconférence, gérer plusieurs comptes et identités.
+- **N6+** : comprendre les protocoles et le chiffrement, choisir des services selon des critères de confidentialité, réagir face à des comportements inappropriés.
+
+### Version Linux et libre
+
+**Courriel**
+
+- **Thunderbird** (avec chiffrement OpenPGP intégré), Evolution, KMail, Geary
+- En terminal : NeoMutt, aerc
+- Webmails libres : Roundcube, SnappyMail
+- Notions à faire comprendre : IMAP vs POP, SMTP, Cci pour protéger les adresses d'un groupe, taille des pièces jointes
+- Fournisseurs soucieux de la vie privée : Disroot, Posteo, mailbox.org, Tuta et Proton (applications open source)
+
+**Messagerie instantanée**
+
+- **Matrix** avec le client Element : décentralisé, fédéré, chiffré de bout en bout
+- **XMPP** : Gajim, Dino (bureau), Conversations (Android), Movim (web)
+- Signal : application libre et chiffrée, mais serveur centralisé
+- Delta Chat : messagerie instantanée qui s'appuie sur le courriel
+- IRC (HexChat, WeeChat) pour découvrir l'historique des communautés libres
+- Notion clé à travailler : centralisé, fédéré, pair à pair
+
+**Visioconférence et audio**
+
+- **Jitsi Meet** : sans compte, dans le navigateur
+- **BigBlueButton** : classes virtuelles (proposé sur apps.education.fr pour les personnels de l'Éducation nationale)
+- Nextcloud Talk, Mumble pour l'audio de groupe
+- Côté Linux : tester webcam et micro (Snapshot, `pavucontrol`), comprendre le partage d'écran sous Wayland
+
+**Planifier les échanges**
+
+- Framadate pour trouver une date commune
+- Agendas partagés via CalDAV : Nextcloud, agenda de Thunderbird
+
+**Savoir-vivre et sécurité**
+
+- Nétiquette : objet clair, pas de « répondre à tous » inutile, majuscules perçues comme des cris
+- Cyberharcèlement : repérer, conserver des preuves, signaler (numéro 3018 pour les jeunes)
+- Hameçonnage : vérifier l'expéditeur réel (lien avec le domaine 4)
+
+### Idées d'activités
+
+- Configurer un compte dans Thunderbird en IMAP, puis envoyer un message à un groupe en Cci
+- Créer un salon Matrix pour la classe ou le groupe, et comparer avec un groupe WhatsApp (qui détient les données, qui peut lire)
+- Organiser une réunion : sondage Framadate, puis séance sur Jitsi ou BigBlueButton avec partage d'écran
+- Échanger un message chiffré OpenPGP entre deux participants dans Thunderbird
+- Analyser des cas de messages problématiques (ton, destinataires, harcèlement) et proposer une réaction adaptée

docs/presentations/Pix orientée Libre/Mener une recherche et une veille d'information.md

@@ -0,0 +1,66 @@
+## 1.1 Mener une recherche et une veille d'information
+
+**Ce que recouvre la compétence** : trouver une information pour répondre à un besoin (moteur de recherche, sites, bases documentaires), évaluer sa fiabilité, et se tenir au courant d'un sujet dans la durée (abonnements, flux, réseaux).
+
+Pix la découpe en grandes thématiques : navigation web, moteurs de recherche, évaluation de l'information, source et citation, veille et curation, filtrage/personnalisation (bulles de filtre), gouvernance et ouverture du web.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : faire une recherche simple, reformuler ses mots-clés, repérer l'auteur et la date d'une page.
+- **N3** : utiliser les fonctions avancées des moteurs, croiser les sources, distinguer information, opinion et publicité.
+- **N4-N5** : construire une stratégie de recherche, mettre en place une veille outillée (flux, alertes).
+- **N6+** : organiser, trier et partager une veille (curation), comprendre les mécanismes des algorithmes de recommandation.
+
+### Version Linux et libre
+
+**Navigation**
+
+- Firefox (ou LibreWolf, sa variante orientée vie privée), Chromium
+- Extensions : uBlock Origin (bloqueur), Privacy Badger
+- En terminal : `lynx` ou `w3m` pour naviguer en texte, `curl`/`wget` pour récupérer une page
+
+**Moteurs de recherche**
+
+- **SearXNG** : métamoteur libre, auto-hébergeable, sans pistage (instances publiques disponibles)
+- Alternatives respectueuses mais non libres : DuckDuckGo, Qwant, Mojeek, Startpage
+- Bases ouvertes : Wikipédia, Wikidata, OpenStreetMap, Internet Archive, HAL (archive ouverte de la recherche française)
+- Opérateurs à maîtriser : `"expression exacte"`, `-exclure`, `site:debian.org`, `filetype:pdf`, `OR`
+
+**Chercher dans la documentation Linux** (spécifique et très formateur)
+
+- `man`, `apropos`, `--help`, `tldr`
+- Wikis communautaires : doc.ubuntu-fr.org, wiki Arch Linux, wiki Debian
+- Forums et suivis de bugs comme sources de solutions (et leur fiabilité variable)
+
+**Veille par flux RSS/Atom**
+
+- Lecteurs locaux : Thunderbird, Liferea, Akregator (KDE), NewsFlash (GNOME), Newsboat (terminal)
+- Auto-hébergés : **FreshRSS** (projet français), Miniflux, Tiny Tiny RSS
+- Surveillance de pages sans flux : changedetection.io
+- Réseaux décentralisés : Mastodon (fédivers), Lemmy, PeerTube, avec abonnement par hashtags
+
+**Curation et conservation**
+
+- **Wallabag** (lire plus tard, français), **Shaarli** (partage de liens, français), Linkding
+- **Zotero** : collecte de références et génération de citations, idéal pour le volet « source et citation »
+- **Joplin** (libre, AGPL) : notes Markdown, Web Clipper pour Firefox (page entière, sélection ou URL avec sa source), synchronisation Nextcloud/WebDAV chiffrée de bout en bout
+- **Obsidian** : gratuit mais **pas libre** ; stocke tout en fichiers Markdown ordinaires, donc les données restent dans un format ouvert. Bon support pour distinguer _logiciel libre_ et _format ouvert_. Web Clipper pour Firefox, synchronisation possible avec Syncthing
+- Alternatives 100 % libres à Obsidian (notes liées, graphe) : **Logseq** (AGPL), **Zettlr** (GPL, intégré à Zotero), **Trilium Notes** (auto-hébergeable)
+- Côté pédagogie : ces outils couvrent les niveaux 5 et plus (organiser sa veille avec étiquettes et liens entre notes, garder la trace des sources)
+
+**Évaluer l'information**
+
+- Wayback Machine pour vérifier l'historique d'une page
+- `whois` et `dig` pour savoir qui est derrière un domaine
+- Métadonnées d'images : `exiftool`
+
+**Droit et ouverture du web**
+
+- Licences Creative Commons, GPL, et Wikimedia Commons pour des ressources réutilisables
+- Repères militants et pédagogiques : Framasoft (et le collectif CHATONS d'hébergeurs alternatifs), La Quadrature du Net, l'April
+
+### Idées d'activités
+
+- Comparer les résultats d'une même requête sur SearXNG, DuckDuckGo et Google pour illustrer la bulle de filtre
+- Résoudre un problème Linux réel uniquement avec `man` et le wiki ubuntu-fr
+- Monter une veille sur un sujet avec FreshRSS ou Newsboat, puis en publier une sélection via Shaarli

docs/presentations/Pix orientée Libre/Partager et publier.md

@@ -0,0 +1,63 @@
+## 2.2 Partager et publier
+
+**Ce que recouvre la compétence** : diffuser ses productions ou ses opinions et relayer celles des autres dans un espace public (réseaux sociaux, blogs, forums, plateformes de partage). Thématiques Pix : règles de visibilité, identité numérique et e-réputation, droit d'auteur et licences, liberté d'expression et ses limites, écriture pour le web, participation citoyenne.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : partager un fichier ou un lien, publier un message simple.
+- **N3** : régler la visibilité d'une publication (public, restreint, privé), respecter le droit à l'image et le droit d'auteur.
+- **N4-N5** : publier sur un blog ou un site, choisir une licence pour ses productions, maîtriser son identité numérique.
+- **N6+** : animer un espace de publication, comprendre les mécanismes de diffusion et d'influence, contribuer à des communs.
+
+### Version Linux et libre
+
+**Le fédivers** (réseaux sociaux décentralisés, notion centrale à faire comprendre)
+
+- **Mastodon** : microblog, avec visibilité réglable (publique, non listée, abonnés, mention privée)
+- **PeerTube** (vidéo, développé par Framasoft), **Pixelfed** (photo), **Lemmy** (forums thématiques), Funkwhale (audio)
+- **WriteFreely** : blog minimaliste qui se suit depuis Mastodon
+- Principe clé : choisir son instance, ses règles de modération, pouvoir déménager son compte
+
+**Blogs et sites**
+
+- **WordPress** (libre), Dotclear, PluXml (français, sans base de données)
+- Sites statiques : Hugo, Jekyll, Zola, hébergés gratuitement via Codeberg Pages ou GitLab Pages
+- Wikis : DokuWiki, MediaWiki
+- Forums : Discourse, Flarum
+
+**Partage de fichiers et de contenus**
+
+- Liens de partage **Nextcloud** avec mot de passe et date d'expiration
+- **CryptPad** : documents partagés chiffrés de bout en bout
+- PrivateBin pour partager un texte de façon chiffrée et éphémère, Lufi pour les fichiers
+
+**Contribuer aux communs** (participation citoyenne)
+
+- Wikipédia, Wikimedia Commons, OpenStreetMap
+- Signaler un bug ou traduire un logiciel libre
+
+**Droit et licences**
+
+- Droit d'auteur et droit à l'image : ce qu'on peut publier, ce qu'il faut demander
+- Licences **Creative Commons** (BY, SA, NC, ND) : comprendre et choisir celle de sa propre production
+- Citer correctement ce qu'on relaie
+- Limites de la liberté d'expression : diffamation, injure, incitation à la haine
+
+**Identité numérique et e-réputation**
+
+- Faire sa « recherche de soi-même » sur plusieurs moteurs (lien avec 1.1)
+- Droit au déréférencement et droit à l'effacement (RGPD, CNIL)
+- Séparer identités personnelle et professionnelle
+
+**Écrire pour le web**
+
+- Markdown, titres clairs, liens explicites
+- Accessibilité : texte alternatif pour les images (pratique très ancrée sur Mastodon), hashtags en `#CamelCase` pour les lecteurs d'écran
+
+### Idées d'activités
+
+- Créer un compte Mastodon, régler la visibilité de trois publications différentes et comparer qui peut les voir
+- Publier un mini-site avec Hugo sur Codeberg Pages, sous licence Creative Commons choisie et justifiée
+- Ajouter une photo personnelle à Wikimedia Commons ou corriger une rue dans OpenStreetMap
+- Audit d'identité numérique : chercher son nom, repérer ce qui est public, faire le ménage
+- Comparer les conditions d'utilisation d'Instagram et d'une instance Pixelfed : à qui appartiennent les contenus publiés ?

docs/presentations/Pix orientée Libre/Programmer.md

@@ -0,0 +1,74 @@
+## 3.4 Programmer
+
+**Ce que recouvre la compétence** : écrire des programmes et des algorithmes pour répondre à un besoin (automatiser une tâche répétitive, résoudre un problème, traiter un volume important) ou pour créer un contenu riche comme un jeu ou un site. Thématiques Pix : algorithmique (séquences, boucles, conditions, variables, fonctions), langages, automatisation, débogage, programmation web.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : lire et comprendre un algorithme simple, programmer des séquences d'instructions par blocs.
+- **N3** : utiliser boucles, conditions et variables, corriger un programme qui ne fonctionne pas.
+- **N4-N5** : passer à un langage textuel, structurer avec des fonctions, automatiser une tâche réelle.
+- **N6+** : concevoir un programme complet, gérer les erreurs, réutiliser des bibliothèques, planifier l'exécution automatique de tâches.
+
+### Version Linux et libre
+
+**Programmation par blocs**
+
+- **Snap!** : libre, dans le navigateur, plus puissant que Scratch
+- **TurboWarp** : version libre et rapide compatible Scratch, avec application de bureau Linux
+- Blockly Games : progression ludique vers la logique de programmation
+
+**Python, le passage naturel au code textuel**
+
+- **Thonny** : conçu pour débuter, avec exécution pas à pas pour visualiser les variables
+- **Basthon** : Python et notebooks dans le navigateur, pensé pour l'enseignement en France
+- JupyterLab pour mêler code, texte et graphiques
+- Module `turtle` pour dessiner, Pyxel ou Pygame pour créer des jeux
+
+**Automatiser sous Linux** (l'atout majeur de l'environnement)
+
+- Scripts **Bash** : boucles sur des fichiers, renommage par lots, sauvegardes
+- Exemple parlant : `for f in *.jpg; do magick "$f" -resize 800x "petit-$f"; done`
+- Planifier des tâches : **cron** ou les minuteurs systemd, ce qui répond directement à la mention des « logiciels de planification de tâches » dans le référentiel
+- Alias et petits scripts dans `~/bin` pour se créer ses propres commandes
+- Macros LibreOffice en Basic ou en Python
+
+**Éditeurs et environnements**
+
+- Geany, Kate : simples et légers
+- **VSCodium** : version libre de VS Code, sans télémétrie
+- nano pour débuter en terminal, Vim ou Emacs pour aller loin
+
+**Web**
+
+- HTML, CSS, JavaScript avec un éditeur et Firefox
+- Outils de développement de Firefox (F12) : inspecter, modifier une page en direct, lire les erreurs
+- **p5.js** : programmation créative et visuelle
+
+**Jeux**
+
+- **Godot** : moteur de jeu libre complet, 2D et 3D
+- GDevelop : création de jeux sans coder ou presque
+
+**Robotique et électronique**
+
+- **Raspberry Pi** : ordinateur sous Linux pour piloter capteurs et moteurs
+- Arduino IDE, MicroPython, micro:bit
+- Thymio : petit robot éducatif avec environnement libre
+
+**La culture du libre**
+
+- Lire le code source d'un logiciel qu'on utilise
+- Versionner son travail avec Git et le publier sur Codeberg (lien 2.3)
+
+**Débogage**
+
+- Lire un message d'erreur, afficher des valeurs intermédiaires, exécuter pas à pas, tester avec des cas limites
+
+### Idées d'activités
+
+- Débuter avec Snap!, puis réécrire le même programme en Python dans Thonny
+- Écrire un script Bash qui trie un dossier de téléchargements par type de fichier, puis le planifier chaque soir avec cron
+- Programmer un petit jeu avec Pyxel ou Godot
+- Modifier une page web en direct avec les outils de développement de Firefox, puis créer la sienne
+- Piloter une LED ou un capteur avec un Raspberry Pi
+- Modifier un petit logiciel libre existant (changer un texte, une couleur) pour comprendre ce que signifie avoir accès au code

docs/presentations/Pix orientée Libre/Protéger la santé, le bien-être et l'environnement.md

@@ -0,0 +1,57 @@
+## 4.3 Protéger la santé, le bien-être et l'environnement
+
+**Ce que recouvre la compétence** : prévenir les effets négatifs du numérique sur la santé physique et psychique et sur l'environnement, mais aussi tirer parti du numérique pour le bien-être, l'inclusion et l'accessibilité. Thématiques Pix : ergonomie et santé physique, sommeil et attention, dépendance et harcèlement, impact environnemental, accessibilité.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : adopter une bonne posture, faire des pauses, limiter les écrans le soir.
+- **N3** : régler son poste pour son confort, gérer ses notifications, connaître les gestes de base pour l'environnement (recyclage).
+- **N4-N5** : maîtriser son temps d'écran, utiliser les outils d'accessibilité, comprendre que l'essentiel de l'impact environnemental vient de la fabrication des appareils.
+- **N6+** : adopter une démarche de sobriété numérique argumentée, concevoir des contenus accessibles et peu gourmands, accompagner les autres.
+
+### Version Linux et libre
+
+**Santé physique et ergonomie**
+
+- Éclairage nocturne intégré à GNOME et KDE (réduction de la lumière bleue le soir)
+- Rappels de pause : **Safe Eyes**, Workrave, Stretchly ; règle 20-20-20 pour les yeux
+- Raccourcis clavier pour limiter l'usage de la souris et les troubles musculo-squelettiques
+- Réglages de la taille du texte, du zoom, de la vitesse du pointeur
+
+**Attention et bien-être psychique**
+
+- Mode « Ne pas déranger » et réglage fin des notifications
+- Les versions récentes de GNOME intègrent un suivi du temps d'écran, des limites et des rappels de pause
+- **LeechBlock NG** (Firefox) : bloquer les sites chronophages à certaines heures
+- **FreeTube** (bureau) et NewPipe (Android) : regarder des vidéos sans recommandations algorithmiques ni publicité
+- Fils chronologiques sans algorithme (Mastodon) vs fils conçus pour retenir l'attention
+- Contrôle parental : Malcontent (GNOME), **CTparental** (libre, français)
+- Cyberharcèlement et mal-être : 3018, Fil Santé Jeunes (lien 2.1)
+
+**Impact environnemental**
+
+- Ordre de grandeur essentiel : la fabrication des appareils pèse bien plus que leur usage, d'où l'enjeu de les garder longtemps
+- **Linux pour prolonger la vie du matériel** : distributions légères (Xubuntu, Lubuntu, Linux Mint XFCE, antiX), Emmabuntüs pour le réemploi, campagne _End of 10_
+- Réparabilité : indice de réparabilité/durabilité, appareils reconditionnés, recyclage des équipements électriques (DEEE)
+- Consommation : TLP et les profils d'énergie pour l'autonomie des portables, `powertop` pour repérer ce qui consomme
+- Mesurer l'empreinte d'une page web : extension **GreenIT-Analysis**, EcoIndex (outils libres français)
+- Sobriété des usages : résolution vidéo adaptée, téléchargement plutôt que streaming répété, en gardant le sens des proportions (trier ses courriels a un effet très faible comparé au fait de garder son ordinateur deux ans de plus)
+- Référentiel général d'écoconception de services numériques (RGESN)
+
+**Accessibilité et inclusion**
+
+- **Orca** : lecteur d'écran
+- Loupe, contraste élevé, grands caractères, curseur agrandi dans les paramètres d'accessibilité
+- Clavier visuel (Onboard), Dasher pour écrire sans clavier
+- Synthèse vocale : espeak-ng, Piper (voix plus naturelles)
+- Dictée vocale hors ligne avec des outils basés sur Whisper (Speech Note)
+- Police Luciole, écriture FALC, documents accessibles (lien 3.1)
+- RGAA : référentiel d'accessibilité des services publics en ligne
+
+### Idées d'activités
+
+- Installer une distribution légère sur un vieil ordinateur et comparer son usage avant et après
+- Mesurer avec GreenIT-Analysis plusieurs sites d'information et classer leur sobriété
+- Tenir pendant une semaine un journal de son temps d'écran, puis mettre en place une règle avec LeechBlock ou les outils de GNOME
+- Utiliser l'ordinateur pendant 15 minutes uniquement avec Orca, écran éteint, pour comprendre les enjeux de l'accessibilité
+- Calculer l'empreinte de son équipement avec le simulateur Impact CO2 de l'ADEME et discuter des leviers réels

docs/presentations/Pix orientée Libre/Protéger les données personnelles et la vie privée.md

@@ -0,0 +1,75 @@
+## 4.2 Protéger les données personnelles et la vie privée
+
+**Ce que recouvre la compétence** : maîtriser ses traces numériques, gérer ses données personnelles et respecter celles des autres, en adoptant des pratiques éclairées. Là où la 4.1 protège contre les attaques, la 4.2 protège contre la collecte et l'exploitation des données, souvent parfaitement légales. Thématiques Pix : données personnelles et sensibles, traces (cookies, historique, métadonnées, géolocalisation), pistage et profilage, paramètres de confidentialité, RGPD, respect de la vie privée d'autrui.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : savoir ce qu'est une donnée personnelle, ne pas diffuser d'informations sur les autres sans accord.
+- **N3** : effacer son historique, régler les paramètres de confidentialité d'un service, comprendre les cookies.
+- **N4-N5** : limiter le pistage, contrôler ses traces (métadonnées, géolocalisation), exercer ses droits RGPD.
+- **N6+** : comprendre le profilage et l'économie des données, choisir des services selon leurs pratiques, conseiller les autres.
+
+### Version Linux et libre
+
+**Comprendre les traces**
+
+- Cookies, pixels espions, empreinte du navigateur (_fingerprinting_)
+- **CookieViz** : outil libre de la CNIL qui montre en direct les échanges avec les pisteurs pendant la navigation
+- Firefox : page `about:protections` qui récapitule les pisteurs bloqués
+- Navigation privée : ce qu'elle efface localement, et ce qu'elle ne cache pas (fournisseur d'accès, sites visités)
+
+**Navigateur protecteur**
+
+- Firefox en protection renforcée (mode strict)
+- **Conteneurs** (Firefox Multi-Account Containers) : isoler ses comptes les uns des autres
+- uBlock Origin, Privacy Badger
+- LibreWolf, Mullvad Browser, Tor Browser selon le niveau de protection voulu
+- Moteurs de recherche sans profilage (lien 1.1)
+
+**Les traces sur son propre poste**
+
+- Paramètres de confidentialité de GNOME ou KDE : localisation, historique des fichiers récents, accès caméra et micro
+- Historique du terminal (`~/.bash_history`)
+- Télémétrie : la plupart des distributions n'en ont pas ou la proposent en option, un point de comparaison intéressant avec les systèmes commerciaux
+
+**Métadonnées**
+
+- Coordonnées GPS dans les photos, auteur dans les documents
+- `exiftool` pour les voir, **mat2** pour les nettoyer (lien 1.2 et 3.3)
+
+**Téléphone**
+
+- **Exodus Privacy** (association française) : liste les pisteurs présents dans les applications Android
+- **F-Droid** : magasin d'applications libres
+- Systèmes alternatifs : /e/OS, LineageOS, GrapheneOS
+- Revoir les permissions des applications (localisation, contacts, micro)
+
+**Limiter les données transmises**
+
+- Principe de minimisation : ne donner que le nécessaire
+- Alias de courriel pour les inscriptions : addy.io, SimpleLogin
+- Fermer les comptes inutilisés
+- Préférer des services hébergés chez un CHATON ou auto-hébergés
+
+**RGPD et droits**
+
+- Droits d'accès, de rectification, d'effacement, d'opposition, de portabilité
+- Modèles de courriers sur le site de la **CNIL**, plainte en cas de refus
+- Exporter ses données (par exemple Google Takeout) pour constater ce qui est conservé
+- Données sensibles : santé, opinions, religion, orientation sexuelle
+
+**Respecter la vie privée des autres**
+
+- Droit à l'image, ne pas publier d'informations sur un tiers
+- Ne pas diffuser de captures de conversations privées
+- Applications qui aspirent tout le carnet d'adresses
+- Cci pour les envois groupés (lien 2.1)
+
+### Idées d'activités
+
+- Naviguer 10 minutes sur des sites d'actualité avec CookieViz et analyser vers où partent les données
+- Passer ses applications Android dans Exodus Privacy et en remplacer une par une alternative de F-Droid
+- Exercer réellement son droit d'accès auprès d'un service et analyser la réponse
+- Télécharger son export Google ou Facebook et découvrir ce qui est conservé
+- Configurer Firefox avec des conteneurs séparés pour les réseaux sociaux, les achats et le reste
+- Retirer la localisation de photos avant de les publier

docs/presentations/Pix orientée Libre/Résoudre des problèmes techniques.md

@@ -0,0 +1,91 @@
+## 5.1 Résoudre des problèmes techniques
+
+**Ce que recouvre la compétence** : diagnostiquer et résoudre des problèmes pour garantir ou rétablir le bon fonctionnement d'un environnement informatique, en utilisant les outils de configuration et de maintenance, et en sachant mobiliser de l'aide. Thématiques Pix : composants matériels et logiciels, diagnostic, maintenance, configuration, réseau, assistance.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : redémarrer un appareil ou une application, vérifier les branchements et la connexion.
+- **N3** : identifier l'origine probable d'une panne (matériel, logiciel, réseau), consulter une aide en ligne, faire les mises à jour.
+- **N4-N5** : diagnostiquer avec les outils du système, installer ou réinstaller un logiciel ou un pilote, décrire précisément un problème pour obtenir de l'aide.
+- **N6+** : analyser des journaux système, dépanner un système qui ne démarre plus, récupérer des données, assister d'autres personnes.
+
+### Version Linux et libre
+
+**Une méthode avant les outils**
+
+- Décrire précisément le symptôme, le reproduire
+- Noter ce qui a changé récemment (mise à jour, installation, nouveau matériel)
+- Isoler la cause, ne modifier qu'une chose à la fois, garder trace de ce qu'on a essayé
+- Chercher le message d'erreur exact (lien 1.1)
+
+**Connaître sa machine**
+
+- `inxi -Fxz` : résumé complet du matériel, idéal à coller dans un forum
+- `cat /etc/os-release`, `uname -r` : distribution et noyau
+- `lspci`, `lsusb`, `lsblk`, `free -h`, `df -h`
+- Interfaces graphiques : À propos (GNOME), Centre d'informations (KDE), Hardinfo2
+
+**Programmes et ressources**
+
+- Moniteur système, `htop` ou `btop` : qui consomme le processeur ou la mémoire
+- Arrêter un programme bloqué : `kill`, `xkill`
+- Interface graphique figée : basculer vers une console avec Ctrl+Alt+F3
+
+**Lire les journaux**
+
+- `journalctl -b -p err` : erreurs depuis le dernier démarrage
+- `dmesg` : messages du noyau (matériel, pilotes)
+- Application Journaux (GNOME) pour une lecture graphique
+
+**Réseau**
+
+- `ping`, `ip a`, `nmcli`, `mtr` : distinguer un problème de câble, de Wi-Fi, de box ou de DNS
+- Pilotes Wi-Fi propriétaires (outil « Pilotes additionnels » sur Ubuntu)
+
+**Logiciels et mises à jour**
+
+- `sudo apt update && sudo apt upgrade`, ou `dnf upgrade`
+- Réparer une installation interrompue : `sudo dpkg --configure -a`, `sudo apt --fix-broken install`
+- Disque plein : `ncdu`, nettoyage du cache des paquets, `flatpak uninstall --unused`
+
+**Périphériques**
+
+- Imprimantes : CUPS (interface sur `localhost:631`)
+- Scanner : Numériseur de documents (Simple Scan), SANE
+- Son : `pavucontrol`, `wpctl status` (PipeWire)
+- Bluetooth : `bluetoothctl`
+- Vérifier la compatibilité d'un matériel avant achat : base linux-hardware.org
+
+**Quand le système ne démarre plus**
+
+- Menu GRUB : démarrer sur un ancien noyau ou en mode de récupération
+- **Clé USB live** (Ventoy pour en avoir plusieurs sur une seule clé) pour accéder aux fichiers et réparer
+- Boot-Repair pour réparer le chargeur de démarrage
+- Timeshift pour revenir à un état antérieur du système
+
+**Matériel et données**
+
+- Santé des disques : GNOME Disques (SMART), `smartctl`
+- Test de la mémoire vive : Memtest86+
+- **TestDisk** et **PhotoRec** : récupérer des partitions ou des fichiers supprimés
+
+**Applications Windows indispensables**
+
+- Wine et Bottles pour certaines applications
+- Machine virtuelle avec GNOME Boxes ou virt-manager
+
+**Demander et donner de l'aide**
+
+- Forums : ubuntu-fr, forums de sa distribution, LinuxFr.org, salons Matrix ou IRC, groupes d'utilisateurs locaux
+- Bien poser une question : distribution et version, matériel, message d'erreur exact, ce qui a déjà été tenté
+- Prudence avec les commandes copiées sans les comprendre (lien 4.1)
+- Assistance à distance : **RustDesk**, SSH
+- Signaler un bug au projet concerné
+
+### Idées d'activités
+
+- Pannes simulées : imprimante en pause, Wi-Fi désactivé, DNS mal configuré, disque plein ; chacun diagnostique et documente
+- Rédiger une demande d'aide modèle sur un forum à partir d'un problème réel, avec la sortie d'`inxi`
+- Récupérer des photos « effacées » d'une clé USB avec PhotoRec
+- Démarrer un ordinateur depuis une clé live et sauver des fichiers d'un système qui ne démarre plus
+- Lire `journalctl` après avoir débranché un périphérique pour apprendre à repérer l'information utile

docs/presentations/Pix orientée Libre/S'insérer dans le monde numérique.md

@@ -0,0 +1,63 @@
+## 2.4 S'insérer dans le monde numérique
+
+**Ce que recouvre la compétence** : comprendre les enjeux de sa présence en ligne et choisir ses pratiques pour agir en tant que citoyen, acteur économique et professionnel dans le monde numérique. C'est la compétence la plus « culture générale » du référentiel. Thématiques Pix : identité et présence en ligne, modèles économiques du numérique, démarches administratives, vie professionnelle, participation citoyenne, questions éthiques et sociétales.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : réaliser une démarche en ligne simple, savoir que ses actions laissent des traces.
+- **N3** : comprendre qu'un service gratuit a un modèle économique, gérer sa présence sur quelques services.
+- **N4-N5** : construire une présence en ligne cohérente avec ses objectifs (emploi, engagement), effectuer des démarches administratives complexes.
+- **N6+** : analyser les enjeux économiques, politiques et éthiques du numérique, faire des choix argumentés et s'engager.
+
+### Version Linux et libre
+
+**Comprendre les modèles économiques**
+
+- « Si c'est gratuit, c'est vous le produit » : publicité ciblée, revente de données, économie de l'attention
+- Freemium, abonnement, achats intégrés
+- Le modèle du libre : dons, services, contributions d'entreprises, financements publics
+- Les **4 libertés** du logiciel libre : utiliser, étudier, modifier, redistribuer
+
+**Enjeux de société**
+
+- Dépendance aux grandes plateformes, souveraineté numérique, interopérabilité
+- Les communs numériques : Wikipédia, OpenStreetMap, logiciels libres
+- Algorithmes de recommandation vs fils chronologiques (comme sur Mastodon)
+- Interfaces trompeuses (_dark patterns_), notifications et captation de l'attention
+
+**Démarches en ligne depuis Linux**
+
+- FranceConnect, impots.gouv, ameli, ANTS fonctionnent dans Firefox
+- Repérer les rares cas où un service impose un logiciel ou un système propriétaire, et savoir le signaler
+
+**Obsolescence et inclusion**
+
+- Redonner vie à un ancien ordinateur sous Linux (distributions légères, Emmabuntüs conçue pour le réemploi)
+- Fin de support de Windows 10 en 2025 : la campagne _End of 10_ propose de passer à Linux plutôt que de jeter son PC
+- Illectronisme : lieux de médiation numérique, conseillers numériques
+
+**Vie professionnelle**
+
+- CV et lettres avec LibreOffice, export PDF
+- Contributions à des projets libres (code, traduction, documentation) comme vitrine de compétences
+- Séparer présence professionnelle et vie privée
+
+**Participation citoyenne**
+
+- Plateformes participatives libres comme **Decidim**, utilisées par des collectivités pour les budgets participatifs et consultations
+- Consultations publiques en ligne, pétitions
+- Contributions aux communs (lien avec 2.2)
+
+**S'engager dans le libre**
+
+- Associations : **April**, **Framasoft**, **La Quadrature du Net**, FSFE, Wikimédia France, OpenStreetMap France
+- Collectif **CHATONS** : hébergeurs alternatifs, éthiques et locaux
+- Groupes d'utilisateurs Linux (GUL), _install parties_, événements comme les JDLL ou le Capitole du Libre
+
+### Idées d'activités
+
+- Lire ensemble les conditions d'utilisation d'un réseau social et identifier comment il gagne de l'argent
+- Débat argumenté : « Une administration devrait-elle utiliser exclusivement des logiciels libres ? »
+- Organiser une mini _install party_ : installer Linux sur un ordinateur destiné à être jeté
+- Réaliser une démarche administrative complète sous Linux et noter les éventuels obstacles
+- Explorer une consultation Decidim d'une collectivité et y analyser la participation

docs/presentations/Pix orientée Libre/Sécuriser l'environnement numérique.md

@@ -0,0 +1,73 @@
+## 4.1 Sécuriser l'environnement numérique
+
+**Ce que recouvre la compétence** : protéger ses équipements, ses communications et ses données contre les attaques, pièges et incidents (logiciels malveillants, hameçonnage, vol de compte, perte de données). Thématiques Pix : menaces et ingénierie sociale, authentification, chiffrement, mises à jour et logiciels de protection, sécurité des réseaux, paiements en ligne.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : verrouiller son poste, ne pas partager ses mots de passe, reconnaître un message suspect évident.
+- **N3** : créer des mots de passe robustes, faire les mises à jour, repérer une connexion sécurisée (HTTPS).
+- **N4-N5** : utiliser un gestionnaire de mots de passe et la double authentification, chiffrer des données, sécuriser son réseau.
+- **N6+** : comprendre les mécanismes d'attaque et de chiffrement, appliquer une politique de sécurité pour un groupe, réagir à un incident.
+
+### Version Linux et libre
+
+**Le modèle de sécurité de Linux**
+
+- Compte utilisateur sans privilèges, `sudo` pour les actions d'administration
+- Logiciels installés depuis des dépôts officiels signés plutôt que téléchargés au hasard
+- Mises à jour centralisées pour tout le système (gestionnaire de logiciels, `apt`, `dnf`), automatisables
+- Flatpak : applications isolées, permissions réglables avec **Flatseal**
+- AppArmor ou SELinux en arrière-plan
+- À démystifier : Linux n'est pas invulnérable. L'hameçonnage, les extensions de navigateur malveillantes, un `curl … | bash` aveugle ou un dépôt tiers douteux restent des risques réels
+
+**Mots de passe et authentification**
+
+- **KeePassXC** : gestionnaire libre, certifié par l'ANSSI
+- Bitwarden (serveur auto-hébergeable avec Vaultwarden)
+- Phrases de passe (méthode Diceware) plutôt que mots de passe complexes impossibles à retenir
+- Vérifier si ses comptes ont fuité : Have I Been Pwned, Mozilla Monitor
+- Double authentification (TOTP) : KeePassXC lui-même, **Aegis** (Android), Authenticator (GNOME)
+- Clés de sécurité physiques FIDO2, dont **Nitrokey** au matériel ouvert ; passkeys
+
+**Chiffrement**
+
+- **LUKS** : chiffrement complet du disque proposé à l'installation de la plupart des distributions
+- VeraCrypt : conteneurs chiffrés, lisibles aussi sous Windows et macOS
+- **Cryptomator** : chiffrer ses fichiers avant de les mettre dans le nuage
+- GnuPG pour les fichiers et courriels (Kleopatra, ou Mots de passe et clés sous GNOME)
+- Clés SSH pour se connecter à un serveur
+- HTTPS et certificats : ce que garantit vraiment le cadenas, et ce qu'il ne garantit pas
+
+**Réseau**
+
+- Pare-feu : `ufw` et son interface **Gufw**, ou firewalld
+- Wi-Fi : WPA2/WPA3, prudence sur les réseaux publics
+- VPN : **WireGuard**, OpenVPN ; ce qu'un VPN protège et ses limites
+- **Tor Browser** pour l'anonymat
+- Firefox : mode HTTPS uniquement, DNS chiffré
+
+**Logiciels de protection**
+
+- ClamAV avec l'interface ClamTk : utile surtout pour analyser des fichiers destinés à des postes Windows ou des clés USB partagées
+- uBlock Origin contre les publicités piégées
+
+**Hameçonnage et ingénierie sociale**
+
+- Vérifier l'adresse réelle d'un lien et l'expéditeur réel (en-têtes dans Thunderbird)
+- Signaler : Signal Spam, **cybermalveillance.gouv.fr**, 17Cyber pour les victimes
+- Rançongiciels : la meilleure protection reste la sauvegarde hors ligne (lien 1.2)
+
+**Bonnes pratiques matérielles**
+
+- Verrouiller sa session (Super + L), mot de passe du BIOS/UEFI
+- Ne pas brancher une clé USB inconnue
+- Référence : guide d'hygiène informatique de l'ANSSI
+
+### Idées d'activités
+
+- Migrer tous ses mots de passe vers KeePassXC et activer la double authentification sur un compte important
+- Créer un conteneur VeraCrypt sur une clé USB et l'ouvrir sous un autre système
+- Atelier hameçonnage : trier une série de vrais et faux messages en justifiant chaque choix
+- Configurer Gufw et vérifier les ports ouverts avec `ss -tulpn`
+- Examiner les permissions de ses applications Flatpak avec Flatseal et en restreindre une
+- Échanger des fichiers chiffrés avec GnuPG entre deux participants

docs/presentations/Pix orientée Libre/Traiter des données.md

@@ -0,0 +1,66 @@
+## 1.3 Traiter des données
+
+**Ce que recouvre la compétence** : appliquer des traitements à des données pour les analyser et les interpréter, avec un tableur, une base de données, un programme ou un outil d'enquête. Thématiques Pix : structure des données, formules et calculs, tri et filtrage, représentation graphique, interprétation critique, formats de données.
+
+### Progression par niveaux (résumé)
+
+- **N1-N2** : saisir des données dans un tableau, faire une somme ou une moyenne simple, trier une colonne.
+- **N3** : écrire des formules, utiliser références relatives et absolues, filtrer, produire un graphique adapté.
+- **N4-N5** : croiser des données (tableaux croisés dynamiques), importer/exporter des formats comme le CSV, mener une enquête et en analyser les résultats.
+- **N6+** : interroger une base de données, automatiser un traitement, détecter un biais ou une représentation trompeuse.
+
+### Version Linux et libre
+
+**Tableur**
+
+- **LibreOffice Calc** : formules, `$A$1` vs `A1`, tri, filtre automatique, validation de données, tableaux croisés dynamiques, graphiques
+- Gnumeric : plus léger, réputé pour la justesse de ses fonctions statistiques
+- **Grist** : entre tableur et base de données, libre, utilisé par l'administration française (auto-hébergeable)
+
+**Formats de données**
+
+- CSV : le piège classique de l'encodage (UTF-8) et du séparateur (`;` en France à cause de la virgule décimale)
+- JSON, XML, ODS ; comprendre qu'un même jeu de données peut circuler sous plusieurs formes
+
+**Bases de données**
+
+- **LibreOffice Base** : tables, relations, formulaires, requêtes
+- **SQLite** avec DB Browser for SQLite : idéal pour découvrir le SQL (`SELECT`, `WHERE`, `GROUP BY`)
+- PostgreSQL ou MariaDB pour aller plus loin
+
+**Nettoyage de données**
+
+- **OpenRefine** : dédoublonner, harmoniser des valeurs, corriger des incohérences
+
+**En ligne de commande** (spécificité Linux très parlante)
+
+- `wc`, `sort`, `uniq -c`, `cut`, `grep`, `awk` : compter et agréger un fichier texte en une ligne
+- `jq` pour le JSON, csvkit ou Miller (`mlr`) pour le CSV
+
+**Programmation et analyse**
+
+- Python avec pandas et matplotlib, dans **JupyterLab**
+- R pour les statistiques
+- gnuplot pour des graphiques scriptés
+
+**Enquêtes**
+
+- **LimeSurvey** : questionnaires et export des résultats vers Calc ou CSV
+
+**Données ouvertes et cartographie**
+
+- data.gouv.fr, INSEE, OpenStreetMap comme sources réelles
+- **QGIS** pour traiter des données géographiques
+
+**Interprétation critique**
+
+- Moyenne vs médiane, corrélation vs causalité
+- Repérer un graphique trompeur : axe tronqué, échelle inadaptée, camembert surchargé
+
+### Idées d'activités
+
+- Télécharger un jeu de données sur data.gouv.fr, résoudre le problème d'import CSV dans Calc, puis produire un graphique
+- Comparer le même calcul fait dans Calc, en SQL sur SQLite et en une ligne de shell
+- Nettoyer un fichier volontairement « sale » avec OpenRefine
+- Créer un questionnaire LimeSurvey dans le groupe, puis analyser les réponses avec un tableau croisé dynamique
+- Corriger un graphique trompeur trouvé dans la presse

docs/presentations/Python/00-installation-environnement.md

@@ -0,0 +1,932 @@
+# Chapitre 00 — Installer Python et son environnement de travail
+
+> **⏱️ Durée estimée :** 2 à 3 heures (installation comprise)
+>
+> **📋 Prérequis :** aucun ! Savoir allumer un ordinateur, télécharger un fichier et taper au clavier suffit. Pense à jeter un œil au [sommaire](README.md) pour avoir une vue d'ensemble du cours.
+>
+> **🎯 Objectifs — À la fin de ce chapitre, tu sauras :**
+> - installer la dernière version stable de Python 3 sur Windows, macOS ou Linux, et vérifier qu'elle fonctionne ;
+> - installer et configurer VS Code avec l'extension Python ;
+> - te déplacer dans tes dossiers avec le terminal (`cd`, `ls`, `dir`) ;
+> - utiliser l'interpréteur interactif de Python comme une calculatrice améliorée ;
+> - écrire, enregistrer et exécuter ton premier script, avec des commentaires ;
+> - lire un message d'erreur de Python sans paniquer et trouver la ligne fautive.
+
+---
+
+## Cours
+
+### 1. Python, c'est quoi exactement ?
+
+Un ordinateur est très rapide mais complètement bête : il ne fait que ce qu'on lui dit, à la lettre. Pour lui donner des ordres, on écrit des **programmes** dans un **langage de programmation**. Python est l'un de ces langages, et c'est sans doute le plus apprécié des débutants, parce qu'il se lit presque comme de l'anglais simplifié.
+
+Voici un programme Python complet :
+
+```python
+print("Bonjour, le monde !")
+```
+
+Sortie :
+
+```text
+Bonjour, le monde !
+```
+
+Une seule ligne, et c'est tout. Dans d'autres langages, il faudrait plusieurs lignes de « cérémonie » pour obtenir le même résultat.
+
+Python est utilisé partout : automatisation de tâches répétitives, sites web, analyse de données, intelligence artificielle, jeux, robotique… Tu découvriras ces domaines au [chapitre 14](14-specialisations.md).
+
+**Comment ça marche ?** Le texte que tu écris (le **code source**) est lu par un programme appelé **l'interpréteur Python**. L'interpréteur lit ton code ligne par ligne, de haut en bas, et exécute chaque instruction. Pense à un cuisinier (l'interpréteur) qui lit une recette (ton code) : il suit les étapes dans l'ordre, et s'il tombe sur une phrase incompréhensible, il s'arrête et te le dit.
+
+Installer Python, c'est donc installer cet interpréteur sur ton ordinateur.
+
+### 2. Installer Python
+
+> 💡 Installe toujours **la dernière version stable de Python 3**, disponible sur le site officiel [python.org](https://www.python.org/downloads/). Ce cours demande au minimum Python 3.12. N'installe jamais « Python 2 » : il est abandonné depuis 2020.
+
+Choisis la section qui correspond à ton système.
+
+#### 2.1. Sous Windows
+
+Il existe aujourd'hui deux façons officielles d'installer Python sous Windows. Les deux fonctionnent ; choisis-en **une seule**.
+
+**Méthode A — L'installateur classique (le plus courant dans les tutoriels)**
+
+1. Va sur [python.org/downloads](https://www.python.org/downloads/) et clique sur le gros bouton jaune *Download Python 3.x.x*. Si le site te propose plutôt le « Python install manager », regarde la méthode B.
+2. Lance le fichier `.exe` téléchargé.
+3. ⚠️ **ÉTAPE CRUCIALE** : tout en bas de la première fenêtre, **coche la case « Add python.exe to PATH »**. Si tu l'oublies, la commande `python` ne sera pas reconnue dans le terminal.
+4. Clique sur *Install Now* et attends la fin de l'installation.
+5. Si un message *Disable path length limit* apparaît à la fin, clique dessus (c'est sans risque et ça évite des soucis plus tard).
+
+> 🤔 **Le PATH, c'est quoi ?** C'est une liste de dossiers dans lesquels Windows cherche les programmes quand tu tapes une commande. Cocher la case ajoute le dossier de Python à cette liste. Sans ça, Windows te répond qu'il ne connaît pas `python`, un peu comme si tu cherchais un livre dans une bibliothèque qui n'a pas de fiche à son nom.
+
+**Méthode B — Le « Python install manager »**
+
+Les versions récentes de Python proposent sous Windows un **gestionnaire d'installation** (Python install manager). Il est disponible dans le **Microsoft Store** (cherche « Python install manager ») ou sur python.org. Une fois installé, il fournit les commandes `python` et `py` : la première fois que tu tapes `python` dans un terminal, il télécharge et installe automatiquement la dernière version stable. Si on te propose d'ajouter un dossier au PATH pendant la configuration, accepte.
+
+> ⚠️ Ne mélange pas les deux méthodes, et si tu tapes `python` et que **le Microsoft Store s'ouvre** tout seul, c'est que Python n'est pas (bien) installé : Windows te propose de l'installer. Dans ce cas, reprends l'une des deux méthodes ci-dessus.
+
+**La commande `py` sous Windows.** Windows propose aussi un petit programme appelé `py` (le « lanceur Python »). Il fonctionne même quand le PATH est mal configuré. Si `python` ne marche pas, essaie `py` :
+
+```text
+C:\Users\camille> py --version
+Python 3.x.y
+```
+
+#### 2.2. Sous macOS
+
+macOS contient parfois un vieux Python, ou un Python installé par les outils de développement d'Apple. Ne t'en sers pas et installe la version officielle :
+
+1. Va sur [python.org/downloads](https://www.python.org/downloads/) et télécharge l'installateur macOS (fichier `.pkg`).
+2. Lance-le et clique sur *Continuer* jusqu'à la fin.
+3. À la fin, une fenêtre du Finder s'ouvre : double-clique sur **`Install Certificates.command`**. Cela permettra à Python de télécharger des choses sur Internet de façon sécurisée (utile au [chapitre 12](12-outils-venv-pip-git.md)).
+
+> 💡 Si tu connais déjà **Homebrew**, `brew install python` fonctionne aussi très bien.
+
+Sous macOS, la commande s'appelle **`python3`** (et pas `python`).
+
+#### 2.3. Sous Linux
+
+La plupart des distributions Linux (Ubuntu, Debian, Fedora…) ont **déjà Python 3** installé, car le système lui-même s'en sert. Vérifie la version (voir section suivante). Si elle est trop ancienne ou absente, utilise le gestionnaire de paquets :
+
+```text
+# Ubuntu / Debian
+sudo apt update
+sudo apt install python3 python3-venv python3-pip
+
+# Fedora
+sudo dnf install python3
+```
+
+> ⚠️ Ne désinstalle **jamais** le Python fourni avec Linux : ton système en a besoin pour fonctionner.
+
+Sous Linux aussi, la commande s'appelle **`python3`**.
+
+#### 2.4. `python`, `python3` ou `py` : qui fait quoi ?
+
+| Système | Commande à utiliser | Remarque |
+|---|---|---|
+| Windows | `python` (ou `py`) | `python3` peut ouvrir le Microsoft Store : évite-la |
+| macOS | `python3` | `python` n'existe souvent pas |
+| Linux | `python3` | `python` peut ne pas exister, ou pointer vers autre chose |
+
+Dans la suite du cours, on écrira `python` dans les exemples de terminal. **Si tu es sous macOS ou Linux, remplace mentalement `python` par `python3`.**
+
+### 3. Le terminal : parler à l'ordinateur en texte
+
+Le **terminal** (on dit aussi « console » ou « ligne de commande ») est une fenêtre où tu tapes des commandes au lieu de cliquer. Ça fait un peu « film de hackers », mais tu n'as besoin que de trois ou quatre commandes.
+
+**Ouvrir un terminal :**
+
+- **Windows** : touche Windows, tape « Terminal » (ou « PowerShell »), puis Entrée.
+- **macOS** : `Cmd` + `Espace`, tape « Terminal », puis Entrée.
+- **Linux** : souvent `Ctrl` + `Alt` + `T`.
+
+Tu vois alors une ligne qui se termine par `>` (Windows) ou `$` / `%` (macOS, Linux) : c'est l'**invite de commande** (le *prompt*). Elle t'indique aussi **le dossier dans lequel tu te trouves**, appelé **dossier courant**.
+
+#### 3.1. Vérifier que Python est installé
+
+Tape la commande suivante, puis Entrée :
+
+```text
+python --version
+```
+
+(ou `python3 --version` sous macOS/Linux, ou `py --version` sous Windows)
+
+Tu dois voir quelque chose comme `Python 3.x.y`, avec un numéro au moins égal à 3.12. 🎉 Si tu obtiens une erreur, va voir la section [Pièges fréquents](#pièges-fréquents).
+
+#### 3.2. Les commandes indispensables
+
+| Action | Windows (PowerShell) | macOS / Linux |
+|---|---|---|
+| Afficher le dossier courant | `pwd` (ou `cd` seul dans l'ancien `cmd`) | `pwd` |
+| Lister le contenu du dossier | `dir` (ou `ls` dans PowerShell) | `ls` |
+| Entrer dans un dossier | `cd nom_du_dossier` | `cd nom_du_dossier` |
+| Remonter d'un niveau | `cd ..` | `cd ..` |
+| Revenir au dossier personnel | `cd ~` | `cd ~` |
+| Créer un dossier | `mkdir nom_du_dossier` | `mkdir nom_du_dossier` |
+| Effacer l'écran | `cls` (ou `clear`) | `clear` |
+
+Imagine que tes dossiers sont des pièces d'une maison. `ls`/`dir` revient à regarder autour de toi, `cd cuisine` à entrer dans la cuisine, `cd ..` à revenir dans le couloir.
+
+Exemple de session (macOS/Linux) :
+
+```text
+$ pwd
+/home/camille
+$ mkdir cours-python
+$ cd cours-python
+$ pwd
+/home/camille/cours-python
+$ ls
+$ cd ..
+$ pwd
+/home/camille
+```
+
+> 💡 **Astuces qui font gagner un temps fou :**
+> - La touche **Tab** complète automatiquement les noms de dossiers et de fichiers : tape `cd cou` puis Tab.
+> - La **flèche du haut** rappelle les commandes précédentes.
+> - Si un nom de dossier contient des espaces, mets-le entre guillemets : `cd "Mes documents"`. Mieux encore : évite les espaces et les accents dans les noms de dossiers de programmation (`cours-python` plutôt que `Cours Python élémentaire`).
+
+**Crée maintenant ton dossier de travail** pour tout le cours, par exemple `cours-python` dans ton dossier personnel, avec `mkdir cours-python`.
+
+### 4. L'interpréteur interactif : Python en direct
+
+Tape simplement `python` (ou `python3`) dans le terminal, sans rien d'autre :
+
+```text
+$ python3
+Python 3.x.y (...)
+Type "help", "copyright", "credits" or "license" for more information.
+>>>
+```
+
+Les trois chevrons `>>>` signifient : « Python t'écoute ». Tu es dans l'**interpréteur interactif** (on dit aussi **REPL** : *Read, Evaluate, Print, Loop* — lire, évaluer, afficher, recommencer). Chaque ligne que tu tapes est exécutée immédiatement.
+
+Essaie-le comme une calculatrice :
+
+```pycon
+>>> 2 + 3
+5
+>>> 10 - 4 * 2
+2
+>>> (10 - 4) * 2
+12
+>>> 7 / 2
+3.5
+>>> 2 ** 10
+1024
+```
+
+Remarques :
+
+- `*` est la multiplication, `/` la division, `**` la puissance (`2 ** 10` = 2 à la puissance 10).
+- Les priorités sont celles des maths : la multiplication passe avant l'addition, sauf si tu mets des parenthèses.
+- Les nombres à virgule s'écrivent avec un **point** : `3.5`, pas `3,5`.
+
+Tu peux aussi manipuler du texte, à condition de le mettre entre guillemets :
+
+```pycon
+>>> "Bonjour"
+'Bonjour'
+>>> "Bon" + "jour"
+'Bonjour'
+>>> "Ha" * 3
+'HaHaHa'
+>>> print("Salut !")
+Salut !
+```
+
+Tous ces détails (types de valeurs, opérateurs) seront approfondis au [chapitre 01](01-variables-types-operateurs.md).
+
+**Pour quitter l'interpréteur**, tape `exit()` puis Entrée (ou `Ctrl` + `D` sous macOS/Linux, `Ctrl` + `Z` puis Entrée sous Windows). Tu reviens alors au terminal normal.
+
+> ⚠️ **Ne confonds pas les deux mondes !**
+> - Après `$` ou `>` : tu parles au **terminal** (commandes `cd`, `ls`, `python`…).
+> - Après `>>>` : tu parles à **Python** (code Python).
+>
+> Taper `cd Documents` après `>>>`, ou `print("Bonjour")` dans le terminal, provoque une erreur.
+
+L'interpréteur interactif est parfait pour tester une petite idée, mais tout ce que tu y tapes disparaît quand tu le fermes. Pour écrire de vrais programmes, on utilise des **scripts** enregistrés dans des fichiers, et un éditeur de code.
+
+### 5. Installer VS Code, ton éditeur de code
+
+Tu pourrais écrire du Python dans le Bloc-notes, mais ce serait comme écrire un roman sans correcteur d'orthographe. Un **éditeur de code** colore ton code, détecte des erreurs à la volée, complète automatiquement ce que tu tapes, et permet d'exécuter ton programme en un clic.
+
+Nous utiliserons **Visual Studio Code** (VS Code), gratuit et disponible sur les trois systèmes.
+
+1. Télécharge-le sur [code.visualstudio.com](https://code.visualstudio.com/) et installe-le.
+   - **Windows** : pendant l'installation, coche « Ajouter à PATH » et « Ajouter l'action *Ouvrir avec Code* », c'est pratique.
+   - **macOS** : glisse l'application dans le dossier *Applications*.
+   - **Linux** : utilise le paquet `.deb` / `.rpm` proposé, ou la logithèque de ta distribution.
+2. Lance VS Code.
+3. Clique sur l'icône **Extensions** dans la barre de gauche (quatre petits carrés), ou fais `Ctrl` + `Shift` + `X` (`Cmd` + `Shift` + `X` sur macOS).
+4. Cherche **« Python »** et installe l'extension publiée par **Microsoft** (c'est la première, avec des millions de téléchargements). Elle installe automatiquement ses compagnons (Pylance, le débogueur…).
+5. (Facultatif) Si tu préfères l'interface en français, installe aussi l'extension **« French Language Pack for Visual Studio Code »** puis redémarre VS Code.
+
+**Ouvrir ton dossier de travail.** Dans VS Code : *Fichier* → *Ouvrir le dossier…* (*File* → *Open Folder…*), puis choisis ton dossier `cours-python`. VS Code peut te demander si tu fais confiance aux auteurs des fichiers : réponds oui, c'est ton dossier.
+
+**Choisir l'interpréteur.** Ouvre la palette de commandes avec `Ctrl` + `Shift` + `P` (`Cmd` + `Shift` + `P` sur macOS), tape « Python: Select Interpreter » et choisis la version de Python que tu viens d'installer. En général VS Code la trouve tout seul.
+
+**Le terminal intégré.** VS Code contient son propre terminal : menu *Terminal* → *Nouveau terminal* (ou ``Ctrl`` + ``ù`` sur un clavier français, ``Ctrl`` + `` ` `` sur un clavier anglais). Il s'ouvre directement dans ton dossier de travail. C'est celui-là que tu utiliseras le plus souvent.
+
+### 6. Ton premier script
+
+Un **script** est simplement un fichier texte qui contient du code Python et dont le nom se termine par **`.py`**.
+
+1. Dans VS Code, crée un nouveau fichier (*Fichier* → *Nouveau fichier*, ou l'icône 📄+ à côté du nom du dossier) et nomme-le **`bonjour.py`**.
+2. Tape ce code :
+
+```python
+print("Bonjour !")
+print("Je m'appelle Python.")
+print("Je sais calculer : 6 x 7 =", 6 * 7)
+```
+
+3. **Enregistre** (`Ctrl` + `S` / `Cmd` + `S`). Un rond blanc à côté du nom de l'onglet signifie « fichier non enregistré » : Python exécute ce qui est **sur le disque**, pas ce qui est à l'écran !
+4. Exécute-le, au choix :
+   - clique sur le bouton ▶ (*Run Python File*) en haut à droite de l'éditeur ;
+   - ou, dans le terminal intégré, tape `python bonjour.py` (ou `python3 bonjour.py`).
+
+Sortie :
+
+```text
+Bonjour !
+Je m'appelle Python.
+Je sais calculer : 6 x 7 = 42
+```
+
+Félicitations, tu es officiellement programmeur ou programmeuse ! 🎉
+
+**Ce qu'il faut remarquer :**
+
+- `print(...)` affiche ce qu'on lui donne entre parenthèses. C'est une **fonction** : un outil prêt à l'emploi fourni par Python. (Tu apprendras à créer tes propres fonctions au [chapitre 05](05-fonctions.md).)
+- Le texte est entre guillemets : `"Bonjour !"`. On appelle ça une **chaîne de caractères**. Sans guillemets, Python croirait que c'est du code.
+- On peut donner plusieurs choses à `print`, séparées par des virgules : Python les affiche séparées par une espace.
+- `6 * 7` n'est pas entre guillemets : Python le calcule et affiche `42`.
+- Les lignes sont exécutées **dans l'ordre**, de haut en bas.
+
+Encore un exemple, pour voir que `print()` sans rien affiche une ligne vide :
+
+```python
+print("Ligne 1")
+print()
+print("Ligne 3, après une ligne vide")
+print("Le résultat de 100 / 8 est", 100 / 8)
+```
+
+Sortie :
+
+```text
+Ligne 1
+
+Ligne 3, après une ligne vide
+Le résultat de 100 / 8 est 12.5
+```
+
+> 💡 **Guillemets simples ou doubles ?** Les deux marchent : `'Bonjour'` et `"Bonjour"` sont identiques. Mais si ton texte contient une apostrophe (très fréquent en français !), utilise des guillemets doubles : `"J'adore Python"`.
+
+### 7. Les commentaires
+
+Un **commentaire** est une note pour les humains, que Python ignore complètement. Il commence par le caractère `#` et s'étend jusqu'à la fin de la ligne.
+
+```python
+# Ce programme affiche un message de bienvenue.
+# Auteur : Camille
+
+print("Bienvenue !")  # un commentaire peut aussi suivre du code
+
+# print("Cette ligne ne sera pas exécutée")
+print("Fin du programme")
+```
+
+Sortie :
+
+```text
+Bienvenue !
+Fin du programme
+```
+
+**À quoi servent les commentaires ?**
+
+- **Expliquer le pourquoi** d'un morceau de code (« on arrondit ici parce que la banque n'accepte pas les centimes de centimes »).
+- **Désactiver temporairement** une ligne sans l'effacer, pour tester quelque chose. Dans VS Code, `Ctrl` + `/` (`Cmd` + `/`) commente ou décommente les lignes sélectionnées.
+- **Structurer** un long script en sections.
+
+> 💡 Un bon commentaire explique **pourquoi**, pas **quoi**. `print("Bonjour")  # affiche Bonjour` n'apporte rien : le code le dit déjà.
+
+### 8. Lire ta première erreur
+
+Tu vas faire des erreurs. Beaucoup. Tout le monde en fait, même les experts avec 20 ans d'expérience. La différence, c'est qu'ils savent **lire les messages d'erreur**. Bonne nouvelle : les messages de Python sont parmi les plus clairs qui existent.
+
+Crée un fichier `erreur.py` avec ce code (il y a une faute volontaire à la ligne 2) :
+
+```python
+print("Bonjour")
+print(Bonjour)
+```
+
+En l'exécutant, tu obtiens :
+
+```text
+Bonjour
+Traceback (most recent call last):
+  File "C:\Users\camille\cours-python\erreur.py", line 2, in <module>
+    print(Bonjour)
+          ^^^^^^^
+NameError: name 'Bonjour' is not defined
+```
+
+Comment lire ce message (on l'appelle un **traceback**) :
+
+1. **Commence par la dernière ligne** : c'est la plus importante. Elle donne le **type d'erreur** (`NameError`) et une explication (`name 'Bonjour' is not defined` : « le nom 'Bonjour' n'est pas défini »).
+2. **Remonte d'une ou deux lignes** pour trouver **où** : le fichier (`erreur.py`) et le numéro de ligne (`line 2`). Python recopie même la ligne fautive et met des `^^^^` sous le morceau problématique.
+3. **Remarque** que la ligne 1 a bien été exécutée (`Bonjour` s'est affiché) : Python s'arrête **à la première erreur rencontrée**.
+
+Ici, on a oublié les guillemets : Python croit que `Bonjour` est un nom de quelque chose qu'il devrait connaître. La correction : `print("Bonjour")`.
+
+Il existe aussi des erreurs détectées **avant même l'exécution**, quand Python relit ton code : les **erreurs de syntaxe** (`SyntaxError`). C'est l'équivalent d'une faute de grammaire.
+
+```python
+print("Bonjour"
+```
+
+```text
+  File "C:\Users\camille\cours-python\erreur.py", line 1
+    print("Bonjour"
+         ^
+SyntaxError: '(' was never closed
+```
+
+Traduction : « la parenthèse ouverte n'a jamais été fermée ». Dans ce cas, **rien** n'est exécuté, même pas les lignes correctes situées avant.
+
+**Petit dictionnaire des erreurs que tu croiseras au début :**
+
+| Message | Signification | Cause probable |
+|---|---|---|
+| `SyntaxError: invalid syntax` | Syntaxe invalide | Faute de frappe, symbole manquant ou en trop |
+| `SyntaxError: '(' was never closed` | Parenthèse jamais fermée | Il manque `)` |
+| `SyntaxError: unterminated string literal` | Chaîne non terminée | Il manque un guillemet fermant |
+| `IndentationError: unexpected indent` | Décalage inattendu | Espaces en trop en début de ligne |
+| `NameError: name '...' is not defined` | Nom inconnu | Faute de frappe, ou guillemets oubliés |
+| `ZeroDivisionError: division by zero` | Division par zéro | On a divisé par 0 |
+
+> 💡 **Le réflexe à prendre :** dernière ligne → numéro de ligne → regarder la ligne en question **et celle d'avant** (une parenthèse oubliée à la ligne 3 est parfois signalée à la ligne 4). Et si tu ne comprends pas, copie la dernière ligne du message dans un moteur de recherche : quelqu'un a déjà eu le même problème. Les erreurs et le débogage seront approfondis au [chapitre 08](08-erreurs-et-debogage.md).
+
+---
+
+## Pièges fréquents
+
+### Piège 1 — « python n'est pas reconnu » (Windows)
+
+```text
+PS C:\Users\camille> python --version
+python : Le terme «python» n'est pas reconnu comme nom d'applet de commande, fonction, fichier de script ou programme exécutable.
+```
+
+**Cause :** la case « Add python.exe to PATH » n'a pas été cochée pendant l'installation.
+
+**Correction :** essaie d'abord `py --version`. Si ça marche, tu peux utiliser `py` à la place de `python`. Sinon, relance l'installateur de Python, choisis *Modify* (ou désinstalle puis réinstalle) et coche bien la case. **Ferme et rouvre ensuite le terminal (et VS Code)** : un terminal déjà ouvert ne voit pas les changements du PATH.
+
+### Piège 2 — « command not found: python » (macOS / Linux)
+
+```text
+$ python --version
+zsh: command not found: python
+```
+
+**Cause :** sur macOS et Linux, la commande s'appelle `python3`.
+
+**Correction :**
+
+```text
+$ python3 --version
+Python 3.x.y
+```
+
+### Piège 3 — Taper du Python dans le terminal, ou une commande de terminal dans Python
+
+Dans le terminal (pas dans Python) :
+
+```text
+$ print("Bonjour")
+bash: syntax error near unexpected token `"Bonjour"'
+```
+
+Dans l'interpréteur Python :
+
+```text
+>>> python bonjour.py
+  File "<stdin>", line 1
+    python bonjour.py
+           ^^^^^^^
+SyntaxError: invalid syntax
+```
+
+**Correction :** regarde l'invite. `>>>` = Python ; `$`, `%` ou `>` = terminal. Pour lancer un script, quitte d'abord l'interpréteur avec `exit()`, puis tape `python bonjour.py` dans le terminal.
+
+### Piège 4 — « No such file or directory »
+
+```text
+$ python3 bonjour.py
+python3: can't open file '/home/camille/bonjour.py': [Errno 2] No such file or directory
+```
+
+**Cause :** tu n'es pas dans le dossier qui contient le fichier (ici, on est dans `/home/camille` alors que le fichier est dans `/home/camille/cours-python`), ou le fichier n'a pas le nom que tu crois (par exemple `bonjour.py.txt` sous Windows).
+
+**Correction :** vérifie où tu es (`pwd`) et ce qu'il y a dans le dossier (`ls` ou `dir`), puis déplace-toi avec `cd cours-python`. Utiliser le terminal intégré de VS Code, qui s'ouvre directement dans le bon dossier, évite souvent ce problème.
+
+### Piège 5 — Oublier d'enregistrer
+
+Tu modifies ton code, tu l'exécutes… et rien ne change. Le rond blanc sur l'onglet de VS Code te dit que le fichier n'est **pas enregistré**.
+
+**Correction :** `Ctrl` + `S` (`Cmd` + `S`) avant chaque exécution. Mieux : active *Fichier* → *Enregistrement automatique* (*Auto Save*).
+
+### Piège 6 — Les guillemets « typographiques »
+
+Si tu copies du code depuis un traitement de texte (Word, un PDF…), les guillemets droits `"` sont parfois remplacés par des guillemets courbes `“ ”` :
+
+```python
+print(“Bonjour”)
+```
+
+```text
+  File "bonjour.py", line 1
+    print(“Bonjour”)
+          ^
+SyntaxError: invalid character '“' (U+201C)
+```
+
+**Correction :** retape les guillemets directement dans VS Code : `print("Bonjour")`. Les guillemets français `« »` provoquent la même erreur.
+
+### Piège 7 — Les majuscules comptent
+
+```python
+Print("Bonjour")
+```
+
+```text
+Traceback (most recent call last):
+  File "bonjour.py", line 1, in <module>
+    Print("Bonjour")
+    ^^^^^
+NameError: name 'Print' is not defined. Did you mean: 'print'?
+```
+
+**Correction :** Python est **sensible à la casse** : `print`, `Print` et `PRINT` sont trois noms différents. Remarque que Python te suggère même la bonne réponse : *Did you mean: 'print'?*
+
+### Piège 8 — Des espaces en trop en début de ligne
+
+```python
+print("Bonjour")
+  print("Au revoir")
+```
+
+```text
+  File "bonjour.py", line 2
+    print("Au revoir")
+IndentationError: unexpected indent
+```
+
+**Correction :** en Python, les espaces en **début** de ligne (l'**indentation**) ont un sens précis, que tu découvriras au [chapitre 02](02-conditions.md). Pour l'instant, toutes tes lignes doivent commencer tout à gauche.
+
+---
+
+## Exercices
+
+### Exercice 1 ⭐ — Vérification de l'installation
+
+Ouvre un terminal et :
+
+1. affiche la version de Python installée ;
+2. crée un dossier `chapitre00` dans ton dossier de travail et entre dedans ;
+3. affiche le chemin du dossier courant pour vérifier que tu es au bon endroit ;
+4. lance l'interpréteur interactif, calcule `2 ** 100`, puis quitte-le.
+
+Résultat attendu pour le calcul : `1267650600228229401496703205376`.
+
+### Exercice 2 ⭐ — Calculatrice interactive
+
+Dans l'interpréteur interactif, calcule :
+
+1. le nombre de secondes dans une journée ;
+2. le nombre de minutes dans une année de 365 jours ;
+3. le prix de 3 croissants à 1,20 € et 2 baguettes à 1,10 € ;
+4. la moyenne de 12, 15 et 17.
+
+Attention aux priorités de calcul et à la virgule !
+
+### Exercice 3 ⭐ — Présente-toi
+
+Écris un script `presentation.py` qui affiche exactement (en mettant tes propres informations) :
+
+```text
+Bonjour !
+Je m'appelle Camille.
+J'apprends Python.
+
+À bientôt !
+```
+
+Note la ligne vide avant la dernière ligne.
+
+### Exercice 4 ⭐⭐ — Chasse aux erreurs
+
+Le script suivant contient **quatre** erreurs. Exécute-le, lis chaque message d'erreur, corrige la ligne fautive et recommence jusqu'à ce que tout fonctionne.
+
+```text
+print("Début du programme")
+print("Le double de 21 est", 21 * 2
+Print("Python est sensible à la casse")
+print("Il manque un guillemet)
+print(Fin du programme)
+```
+
+Sortie attendue une fois corrigé :
+
+```text
+Début du programme
+Le double de 21 est 42
+Python est sensible à la casse
+Il manque un guillemet
+Fin du programme
+```
+
+### Exercice 5 ⭐⭐ — Le commentateur
+
+Écris un script `recette.py` qui affiche une petite recette de crêpes (titre, ingrédients, étapes) sur une dizaine de lignes. Ajoute :
+
+- un commentaire en tête avec ton nom et la date ;
+- un commentaire avant chaque section (titre, ingrédients, étapes) ;
+- une ligne d'étape « désactivée » par un commentaire, qui ne doit pas s'afficher.
+
+### Exercice 6 ⭐⭐ — Facture rapide
+
+Écris un script `facture.py` qui affiche une facture et laisse Python faire **tous** les calculs (n'écris pas les résultats toi-même). Un client achète 4 cahiers à 2.5 € et 3 stylos à 1.2 €.
+
+Sortie attendue :
+
+```text
+=== FACTURE ===
+Cahiers : 4 x 2.5 = 10.0 €
+Stylos  : 3 x 1.2 = 3.5999999999999996 €
+TOTAL   : 13.6 €
+```
+
+Ne t'inquiète pas du `3.5999999999999996` : c'est normal, et tu sauras pourquoi (et comment l'arrondir) au chapitre 01.
+
+### Exercice 7 ⭐⭐⭐ — Art ASCII
+
+Écris un script `chat.py` qui dessine ce chat (attention : la barre oblique inversée `\` est un caractère spécial en Python ; pour l'afficher, il faut l'écrire en double `\\` dans une chaîne).
+
+```text
+ /\_/\
+( o.o )
+ > ^ <
+```
+
+Puis ajoute un cadre de 20 étoiles au-dessus et au-dessous, **sans taper les 20 étoiles à la main** (indice : tu as vu ce que fait `"Ha" * 3`).
+
+---
+
+## Mini-projet
+
+### Ma carte de visite dans le terminal
+
+**Objectif :** créer un script `carte_visite.py` qui affiche une jolie carte de visite à ton nom, encadrée, et qui calcule une ou deux informations « amusantes ».
+
+**Cahier des charges :**
+
+1. Le fichier commence par un commentaire d'en-tête : nom du programme, auteur, date, description en une phrase.
+2. La carte est encadrée par une ligne de 40 caractères `=` en haut et en bas, générée avec l'opérateur `*` sur une chaîne.
+3. Elle contient au moins : ton prénom, ta ville, un loisir, et la phrase « Apprenti·e Pythoniste ».
+4. Une section « Le saviez-vous ? » affiche au moins deux calculs faits par Python, par exemple ton âge approximatif en jours (âge × 365) et le nombre d'heures de sommeil par an (8 × 365).
+5. Les sections sont séparées par des lignes vides et commentées dans le code.
+6. Le script s'exécute sans aucune erreur depuis le terminal **et** depuis le bouton ▶ de VS Code.
+
+**Étapes suggérées :**
+
+1. Crée le fichier dans ton dossier de travail et écris le commentaire d'en-tête.
+2. Affiche le cadre du haut, puis teste.
+3. Ajoute les lignes d'information une par une, en testant à chaque fois.
+4. Ajoute la section des calculs.
+5. Termine par le cadre du bas et relis les commentaires.
+
+**Pistes d'amélioration :**
+
+- Ajoute un petit dessin ASCII (un chat, une tasse de café…).
+- Centre visuellement les textes en ajoutant des espaces.
+- Ajoute le nombre de battements de cœur approximatif depuis ta naissance (environ 70 par minute).
+- Quand tu auras lu le chapitre 01, reviens améliorer ce script avec des variables et une saisie au clavier !
+
+---
+
+## Corrigés
+
+<details>
+<summary>Corrigé de l'exercice 1</summary>
+
+Sous macOS / Linux (sous Windows, remplace `python3` par `python` ou `py`, et `pwd` fonctionne dans PowerShell) :
+
+```text
+$ python3 --version
+Python 3.x.y
+$ mkdir chapitre00
+$ cd chapitre00
+$ pwd
+/home/camille/cours-python/chapitre00
+$ python3
+>>> 2 ** 100
+1267650600228229401496703205376
+>>> exit()
+$
+```
+
+Remarque : Python calcule sans problème des nombres entiers gigantesques, contrairement à une calculatrice de poche qui afficherait `1.2676506e+30`.
+
+</details>
+
+<details>
+<summary>Corrigé de l'exercice 2</summary>
+
+```pycon
+>>> 24 * 60 * 60
+86400
+>>> 365 * 24 * 60
+525600
+>>> 3 * 1.20 + 2 * 1.10
+5.8
+>>> (12 + 15 + 17) / 3
+14.666666666666666
+```
+
+- Pour les prix, on écrit `1.20` avec un point, jamais une virgule. (Parfois, un calcul avec des nombres à virgule donne un résultat comme `3.5999999999999996` au lieu de `3.6` : c'est une petite imprécision normale en informatique, expliquée au chapitre 01.)
+- Pour la moyenne, les **parenthèses sont indispensables** : `12 + 15 + 17 / 3` calculerait d'abord `17 / 3` et donnerait `32.666666666666664`.
+
+</details>
+
+<details>
+<summary>Corrigé de l'exercice 3</summary>
+
+```python
+print("Bonjour !")
+print("Je m'appelle Camille.")
+print("J'apprends Python.")
+print()
+print("À bientôt !")
+```
+
+Sortie :
+
+```text
+Bonjour !
+Je m'appelle Camille.
+J'apprends Python.
+
+À bientôt !
+```
+
+On utilise des guillemets doubles car le texte contient des apostrophes. `print()` sans argument affiche une ligne vide.
+
+</details>
+
+<details>
+<summary>Corrigé de l'exercice 4</summary>
+
+Les quatre erreurs, dans l'ordre où Python les signale :
+
+1. Ligne 4 : `SyntaxError: unterminated string literal (detected at line 4)` → il manque le guillemet fermant. Surprise : ce n'est pas la ligne 2 qui est signalée en premier ! Python découpe d'abord tout le fichier en « mots », et une chaîne non terminée bloque ce découpage dès le départ.
+2. Ligne 2 : `SyntaxError: '(' was never closed` → il manque la parenthèse fermante.
+3. Ligne 5 : `SyntaxError: invalid syntax. Perhaps you forgot a comma?` → Python lit `Fin du programme` comme trois noms de code à la suite, ce qui n'a pas de sens. La vraie cause : les guillemets oubliés.
+4. Ligne 3 : `NameError: name 'Print' is not defined. Did you mean: 'print'?` → majuscule en trop. Cette erreur n'apparaît qu'en dernier, **pendant l'exécution** : les deux premières lignes s'affichent avant que Python ne plante.
+
+À retenir : tant qu'il reste une erreur de syntaxe (`SyntaxError`), **rien** ne s'exécute. Les autres erreurs (`NameError`…) n'apparaissent qu'au moment où Python atteint la ligne fautive.
+
+Version corrigée :
+
+```python
+print("Début du programme")
+print("Le double de 21 est", 21 * 2)
+print("Python est sensible à la casse")
+print("Il manque un guillemet")
+print("Fin du programme")
+```
+
+Sortie :
+
+```text
+Début du programme
+Le double de 21 est 42
+Python est sensible à la casse
+Il manque un guillemet
+Fin du programme
+```
+
+</details>
+
+<details>
+<summary>Corrigé de l'exercice 5</summary>
+
+```python
+# Recette de crêpes
+# Auteur : Camille — 14 octobre
+
+# --- Titre ---
+print("=== Crêpes pour 4 personnes ===")
+print()
+
+# --- Ingrédients ---
+print("Ingrédients :")
+print("- 250 g de farine")
+print("- 4 œufs")
+print("- 50 cl de lait")
+print("- 1 pincée de sel")
+print()
+
+# --- Étapes ---
+print("Étapes :")
+print("1. Mélanger la farine et les œufs.")
+print("2. Ajouter le lait petit à petit.")
+# print("2bis. Ajouter un verre de rhum.")  # étape désactivée
+print("3. Laisser reposer 1 heure.")
+print("4. Cuire dans une poêle chaude.")
+```
+
+Sortie :
+
+```text
+=== Crêpes pour 4 personnes ===
+
+Ingrédients :
+- 250 g de farine
+- 4 œufs
+- 50 cl de lait
+- 1 pincée de sel
+
+Étapes :
+1. Mélanger la farine et les œufs.
+2. Ajouter le lait petit à petit.
+3. Laisser reposer 1 heure.
+4. Cuire dans une poêle chaude.
+```
+
+La ligne « 2bis » est commentée : Python l'ignore.
+
+</details>
+
+<details>
+<summary>Corrigé de l'exercice 6</summary>
+
+```python
+# Facture : Python fait tous les calculs
+print("=== FACTURE ===")
+print("Cahiers : 4 x 2.5 =", 4 * 2.5, "€")
+print("Stylos  : 3 x 1.2 =", 3 * 1.2, "€")
+print("TOTAL   :", 4 * 2.5 + 3 * 1.2, "€")
+```
+
+Sortie :
+
+```text
+=== FACTURE ===
+Cahiers : 4 x 2.5 = 10.0 €
+Stylos  : 3 x 1.2 = 3.5999999999999996 €
+TOTAL   : 13.6 €
+```
+
+Dans `"4 x 2.5 ="`, le calcul est entre guillemets : c'est du texte, affiché tel quel. Juste après, `4 * 2.5` est hors guillemets : Python le calcule. Remarque qu'on recopie les mêmes nombres plusieurs fois : au chapitre 01, les **variables** permettront d'éviter ça.
+
+</details>
+
+<details>
+<summary>Corrigé de l'exercice 7</summary>
+
+```python
+# Un chat en art ASCII, encadré d'étoiles
+print("*" * 20)
+print(" /\\_/\\")
+print("( o.o )")
+print(" > ^ <")
+print("*" * 20)
+```
+
+Sortie :
+
+```text
+********************
+ /\_/\
+( o.o )
+ > ^ <
+********************
+```
+
+Chaque `\\` dans le code produit **un seul** `\` à l'écran. `"*" * 20` répète la chaîne `"*"` vingt fois.
+
+</details>
+
+<details>
+<summary>Corrigé du mini-projet</summary>
+
+```python
+# ------------------------------------------------------------
+# carte_visite.py
+# Auteur : Camille
+# Date : 14 octobre
+# Description : affiche ma carte de visite dans le terminal.
+# ------------------------------------------------------------
+
+# --- Cadre du haut ---
+print("=" * 40)
+
+# --- Identité ---
+print("  Camille")
+print("  Apprentie Pythoniste")
+print()
+
+# --- Informations ---
+print("  Ville  : Lyon")
+print("  Loisir : l'escalade")
+print()
+
+# --- Le saviez-vous ? (calculs faits par Python) ---
+print("  Le saviez-vous ?")
+print("  J'ai vécu environ", 28 * 365, "jours.")
+print("  Je dors environ", 8 * 365, "heures par an.")
+print("  Mon cœur a battu environ", 70 * 60 * 24 * 365 * 28, "fois.")
+
+# --- Cadre du bas ---
+print("=" * 40)
+```
+
+Sortie :
+
+```text
+========================================
+  Camille
+  Apprentie Pythoniste
+
+  Ville  : Lyon
+  Loisir : l'escalade
+
+  Le saviez-vous ?
+  J'ai vécu environ 10220 jours.
+  Je dors environ 2920 heures par an.
+  Mon cœur a battu environ 1030176000 fois.
+========================================
+```
+
+Points à vérifier : le commentaire d'en-tête est présent, chaque section est commentée, les cadres sont générés avec `"=" * 40`, et tous les nombres sont calculés par Python. Le nombre de battements de cœur correspond à l'une des pistes d'amélioration.
+
+</details>
+
+---
+
+## Récapitulatif
+
+**Points clés :**
+
+- Python est un langage **interprété** : l'interpréteur lit ton code de haut en bas et l'exécute ligne par ligne.
+- Installe **la dernière version stable de Python 3** depuis python.org. Sous Windows, **coche « Add python.exe to PATH »** (ou utilise le Python install manager).
+- La commande est `python` (ou `py`) sous Windows, `python3` sous macOS et Linux.
+- Dans le terminal : `cd` pour te déplacer, `cd ..` pour remonter, `ls` / `dir` pour lister, `pwd` pour savoir où tu es, `mkdir` pour créer un dossier.
+- `>>>` = interpréteur interactif (tests rapides) ; un fichier `.py` = script (programme durable). On lance un script avec `python nom_du_fichier.py`.
+- VS Code + l'extension Python de Microsoft : ton atelier de travail. N'oublie pas d'enregistrer avant d'exécuter.
+- `print(...)` affiche des valeurs ; le texte se met entre guillemets.
+- `#` commence un commentaire, ignoré par Python.
+- Un message d'erreur se lit **de bas en haut** : type d'erreur, explication, puis numéro de ligne.
+
+**Checklist de validation :**
+
+- [ ] `python --version` (ou `python3 --version`) affiche une version 3.12 ou plus récente.
+- [ ] Je sais ouvrir un terminal, savoir où je suis et me déplacer dans mes dossiers.
+- [ ] Je sais lancer l'interpréteur interactif, y faire un calcul et le quitter.
+- [ ] VS Code est installé avec l'extension Python, et mon dossier de travail est ouvert dedans.
+- [ ] J'ai écrit, enregistré et exécuté un script `.py` de deux façons (bouton ▶ et terminal).
+- [ ] Je sais écrire un commentaire et désactiver une ligne.
+- [ ] Face à une erreur, je sais trouver son type et le numéro de la ligne fautive.
+
+---
+
+[← Chapitre précédent (sommaire)](README.md) | [Sommaire](README.md) | [Chapitre suivant →](01-variables-types-operateurs.md)

docs/presentations/Python/README.md

@@ -0,0 +1,130 @@
+# Apprendre à programmer en Python
+
+Un parcours complet, du tout premier `print()` jusqu'à un projet personnel publié sur GitHub.
+
+Ce dossier s'adresse aux **grands débutants** : aucune connaissance préalable en programmation n'est nécessaire. Chaque chapitre explique les notions pas à pas, avec des exemples que tu peux exécuter, les erreurs que tout le monde fait au début, des exercices corrigés et un mini-projet.
+
+---
+
+## Comment utiliser ce cours
+
+1. **Suis les chapitres dans l'ordre.** Chacun s'appuie sur les précédents.
+2. **Tape les exemples toi-même** au lieu de les copier-coller. C'est en tapant (et en se trompant) qu'on retient.
+3. **Fais les exercices avant de regarder les corrigés.** Les corrigés sont repliés : clique sur « Corrigé de l'exercice N » seulement après avoir vraiment cherché (au moins 15 à 20 minutes).
+4. **Ne saute pas les mini-projets.** Ce sont eux qui transforment des notions isolées en vraie compétence.
+5. **Coche la checklist** à la fin de chaque chapitre. Si une case reste vide, relis la partie concernée avant d'avancer.
+6. **Garde l'[aide-mémoire](aide-memoire.md) ouvert** pendant que tu codes.
+
+> **Conseil de rythme** : 30 à 60 minutes par jour valent mieux qu'une seule longue séance par semaine. Le cerveau consolide pendant les pauses.
+
+---
+
+## Sommaire
+
+### Partie 1 — Les fondamentaux
+
+| # | Chapitre | Ce que tu apprends | Travail |
+|---|---|---|---|
+| 00 | [Installation et environnement](00-installation-environnement.md) | Installer Python et VS Code, utiliser le terminal, écrire et lancer ton premier script | 2-3 h |
+| 01 | [Variables, types et opérateurs](01-variables-types-operateurs.md) | Stocker des données, nombres et textes, calculs, `input()` / `print()`, f-strings | 4-5 h |
+| 02 | [Conditions](02-conditions.md) | Prendre des décisions avec `if` / `elif` / `else`, opérateurs logiques, `match` | 4 h |
+| 03 | [Boucles](03-boucles.md) | Répéter des actions avec `for` et `while`, `range()`, `break`, `continue` | 5 h |
+
+### Partie 2 — Organiser ses données et son code
+
+| # | Chapitre | Ce que tu apprends | Travail |
+|---|---|---|---|
+| 04 | [Structures de données](04-structures-de-donnees.md) | Listes, tuples, dictionnaires, ensembles | 5-6 h |
+| 05 | [Fonctions](05-fonctions.md) | Découper son code en blocs réutilisables, paramètres, retour, portée | 5-6 h |
+| 06 | [Chaînes et compréhensions](06-chaines-et-comprehensions.md) | Manipuler du texte, slicing, compréhensions, `enumerate`, `zip`, `sorted` | 5-6 h |
+| 07 | [Fichiers, CSV et JSON](07-fichiers-csv-json.md) | Lire et écrire des fichiers, sauvegarder des données durablement | 5-6 h |
+
+### Partie 3 — Écrire du code solide
+
+| # | Chapitre | Ce que tu apprends | Travail |
+|---|---|---|---|
+| 08 | [Erreurs et débogage](08-erreurs-et-debogage.md) | Lire un traceback, gérer les exceptions, utiliser le débogueur | 4-5 h |
+| 09 | [Modules et bibliothèque standard](09-modules-bibliotheque-standard.md) | Importer, créer ses propres modules, `random`, `datetime`, `collections`… | 4-5 h |
+
+### Partie 4 — Programmation orientée objet
+
+| # | Chapitre | Ce que tu apprends | Travail |
+|---|---|---|---|
+| 10 | [Classes et objets](10-poo-classes-objets.md) | Créer ses propres types, attributs, méthodes, `self` | 5-6 h |
+| 11 | [POO avancée et typage](11-poo-avancee-heritage-typage.md) | Héritage, composition, `@property`, dataclasses, annotations de type | 6-7 h |
+
+### Partie 5 — Travailler comme un développeur
+
+| # | Chapitre | Ce que tu apprends | Travail |
+|---|---|---|---|
+| 12 | [Outils : venv, pip, Git](12-outils-venv-pip-git.md) | Environnements virtuels, installer des paquets, versionner et publier son code | 5-7 h |
+| 13 | [Tests et bonnes pratiques](13-tests-pytest-bonnes-pratiques.md) | Tester avec `pytest`, PEP 8, `ruff`, structurer un projet | 5-7 h |
+
+### Partie 6 — Aller plus loin
+
+| # | Chapitre | Ce que tu apprends | Travail |
+|---|---|---|---|
+| 14 | [Spécialisations](14-specialisations.md) | Automatisation, web, data, IA, jeux : un aperçu concret de chaque voie | 8-12 h |
+| 15 | [Projet final](15-projet-final.md) | Mener un projet de A à Z, idées de projets, projet fil rouge guidé | 15-30 h |
+
+### Annexes
+
+- [Aide-mémoire Python](aide-memoire.md) — toute la syntaxe essentielle sur une page
+- [Ressources](ressources.md) — livres, sites, plateformes d'exercices, communautés
+
+---
+
+## Planning type
+
+La colonne « Travail » du sommaire indique le temps pour le cours, les exercices et le mini-projet d'un chapitre. Ajoute-y de la pratique libre (exercices sur France-IOI ou Codewars, petits scripts personnels, révisions) : c'est elle qui ancre les notions. En pratique, compte **environ une semaine par chapitre**.
+
+Avec **5 à 7 heures par semaine**, compte environ **6 mois** pour le parcours complet :
+
+```
+Mois 1  ██████████  Ch. 00 → 03   Fondamentaux
+Mois 2  ██████████  Ch. 04 → 07   Données, fonctions, fichiers
+Mois 3  ██████████  Ch. 08 → 09   Code solide + révisions
+Mois 4  ██████████  Ch. 10 → 13   POO et outils du développeur
+Mois 5  ██████████  Ch. 14        Spécialisation choisie
+Mois 6  ██████████  Ch. 15        Projet personnel
+```
+
+Avec **10 à 15 heures par semaine**, le parcours se fait en 3 mois environ. Avec moins de temps, étale-le : la régularité compte plus que la vitesse.
+
+---
+
+## Suivi de progression
+
+Coche au fur et à mesure :
+
+- [ ] 00 — Installation et environnement
+- [ ] 01 — Variables, types et opérateurs
+- [ ] 02 — Conditions
+- [ ] 03 — Boucles
+- [ ] 04 — Structures de données
+- [ ] 05 — Fonctions
+- [ ] 06 — Chaînes et compréhensions
+- [ ] 07 — Fichiers, CSV et JSON
+- [ ] 08 — Erreurs et débogage
+- [ ] 09 — Modules et bibliothèque standard
+- [ ] 10 — Classes et objets
+- [ ] 11 — POO avancée et typage
+- [ ] 12 — Outils : venv, pip, Git
+- [ ] 13 — Tests et bonnes pratiques
+- [ ] 14 — Spécialisation choisie : ____________
+- [ ] 15 — Projet final publié sur GitHub
+
+---
+
+## Quand tu es bloqué
+
+1. **Relis le message d'erreur**, en partant de la dernière ligne (le chapitre 08 t'apprend à le faire méthodiquement).
+2. **Ajoute des `print()`** pour voir ce que contiennent tes variables à chaque étape.
+3. **Réduis le problème** : isole les quelques lignes qui posent souci dans un petit fichier à part.
+4. **Cherche le message d'erreur** sur un moteur de recherche (souvent en anglais).
+5. **Fais une pause.** Beaucoup de bugs se résolvent tout seuls après dix minutes loin de l'écran.
+6. **Demande de l'aide** en expliquant ce que tu voulais faire, ce que tu as essayé et le message d'erreur complet (voir [Ressources](ressources.md) pour les communautés).
+
+Bon apprentissage !
+
+[Commencer le chapitre 00 →](00-installation-environnement.md)

docs/presentations/Python/aide-memoire.md

@@ -0,0 +1,526 @@
+# Aide-mémoire Python
+
+Toute la syntaxe essentielle du cours, regroupée pour la retrouver vite. Les numéros entre parenthèses renvoient au chapitre où la notion est expliquée en détail.
+
+---
+
+## Sommaire
+
+1. [Bases](#1-bases-ch-01)
+2. [Conditions](#2-conditions-ch-02)
+3. [Boucles](#3-boucles-ch-03)
+4. [Listes](#4-listes-ch-04)
+5. [Tuples et ensembles](#5-tuples-et-ensembles-ch-04)
+6. [Dictionnaires](#6-dictionnaires-ch-04)
+7. [Fonctions](#7-fonctions-ch-05)
+8. [Chaînes de caractères](#8-chaînes-de-caractères-ch-06)
+9. [Compréhensions et outils d'itération](#9-compréhensions-et-outils-ditération-ch-06)
+10. [Fichiers, CSV, JSON](#10-fichiers-csv-json-ch-07)
+11. [Exceptions](#11-exceptions-ch-08)
+12. [Modules utiles](#12-modules-utiles-ch-09)
+13. [Classes](#13-classes-ch-10-et-11)
+14. [Annotations de type](#14-annotations-de-type-ch-11)
+15. [Commandes du terminal](#15-commandes-du-terminal-ch-00-12-13)
+16. [Erreurs courantes et leur sens](#16-erreurs-courantes-et-leur-sens)
+
+---
+
+## 1. Bases (ch. 01)
+
+```python
+# Commentaire sur une ligne
+
+nom = "Alice"          # str  : texte
+age = 30               # int  : entier
+taille = 1.68          # float: nombre à virgule
+majeur = True          # bool : True / False
+rien = None            # absence de valeur
+
+type(age)              # <class 'int'>
+```
+
+**Conversions**
+
+```python
+int("42")      # 42
+float("3.5")   # 3.5
+str(42)        # "42"
+bool(0)        # False  (0, "", [], {}, None sont « faux »)
+int(3.9)       # 3      (tronque, n'arrondit pas)
+round(3.9)     # 4
+```
+
+**Opérateurs**
+
+| Opérateur | Sens | Exemple | Résultat |
+|---|---|---|---|
+| `+ - *` | addition, soustraction, multiplication | `7 * 2` | `14` |
+| `/` | division (toujours un float) | `7 / 2` | `3.5` |
+| `//` | division entière | `7 // 2` | `3` |
+| `%` | reste (modulo) | `7 % 2` | `1` |
+| `**` | puissance | `2 ** 10` | `1024` |
+| `+=`, `-=`… | raccourcis | `x += 1` | `x = x + 1` |
+
+**Entrées / sorties**
+
+```python
+prenom = input("Ton prénom ? ")          # renvoie toujours un str
+age = int(input("Ton âge ? "))           # convertir pour calculer
+
+print("Bonjour", prenom)                 # Bonjour Alice
+print(f"{prenom} a {age} ans")           # f-string
+print(f"Prix : {12.5:.2f} €")            # Prix : 12.50 €
+print(f"{42:>6}")                        # '    42' (aligné à droite sur 6)
+print("a", "b", sep="-", end="!\n")      # a-b!
+```
+
+---
+
+## 2. Conditions (ch. 02)
+
+```python
+if note >= 16:
+    print("Très bien")
+elif note >= 10:
+    print("Admis")
+else:
+    print("Recalé")
+```
+
+| Comparaison | Logique |
+|---|---|
+| `==` égal, `!=` différent | `and` : les deux vrais |
+| `<`, `<=`, `>`, `>=` | `or` : au moins un vrai |
+| `in`, `not in` (appartenance) | `not` : inverse |
+| `is None`, `is not None` | |
+
+```python
+if 0 <= age < 18:                  # comparaisons enchaînées
+    ...
+statut = "majeur" if age >= 18 else "mineur"   # condition sur une ligne
+
+match commande:                    # Python 3.10+
+    case "q" | "quitter":
+        print("Au revoir")
+    case "aide":
+        print("Commandes : ...")
+    case _:
+        print("Commande inconnue")
+```
+
+---
+
+## 3. Boucles (ch. 03)
+
+```python
+for i in range(5):           # 0, 1, 2, 3, 4
+    print(i)
+
+range(2, 10)                 # 2 à 9
+range(10, 0, -2)             # 10, 8, 6, 4, 2
+
+for lettre in "abc":         # parcourt n'importe quel itérable
+    print(lettre)
+
+compteur = 0
+while compteur < 3:
+    compteur += 1
+
+while True:                  # boucle infinie + sortie contrôlée
+    reponse = input("> ")
+    if reponse == "q":
+        break                # sort de la boucle
+    if reponse == "":
+        continue             # passe au tour suivant
+    print(reponse)
+```
+
+> `Ctrl + C` dans le terminal arrête un programme coincé dans une boucle infinie.
+
+---
+
+## 4. Listes (ch. 04)
+
+```python
+fruits = ["pomme", "banane", "kiwi"]
+
+fruits[0]            # "pomme"   (premier)
+fruits[-1]           # "kiwi"    (dernier)
+fruits[1:3]          # ["banane", "kiwi"]
+len(fruits)          # 3
+"kiwi" in fruits     # True
+
+fruits.append("poire")       # ajoute à la fin
+fruits.insert(0, "fraise")   # insère à l'indice 0
+fruits.remove("banane")      # retire la première occurrence
+dernier = fruits.pop()       # retire et renvoie le dernier
+fruits.sort()                # trie sur place
+fruits.reverse()             # inverse sur place
+fruits.index("kiwi")         # position d'un élément
+fruits.count("pomme")        # nombre d'occurrences
+
+copie = fruits.copy()        # vraie copie (ou fruits[:])
+sum([1, 2, 3]), min([4, 2]), max([4, 2])   # 6, 2, 4
+```
+
+> **Attention** : `b = a` ne copie pas la liste, les deux noms désignent la même liste.
+
+---
+
+## 5. Tuples et ensembles (ch. 04)
+
+```python
+point = (3, 4)               # tuple : non modifiable
+x, y = point                 # déballage
+a, b = b, a                  # échanger deux variables
+
+couleurs = {"rouge", "vert"} # set : pas de doublons, pas d'ordre
+couleurs.add("bleu")
+couleurs.discard("vert")
+set([1, 1, 2])               # {1, 2}
+
+a, b = {1, 2, 3}, {2, 3, 4}
+a | b    # {1, 2, 3, 4}  union
+a & b    # {2, 3}        intersection
+a - b    # {1}           différence
+```
+
+---
+
+## 6. Dictionnaires (ch. 04)
+
+```python
+eleve = {"nom": "Alice", "age": 17}
+
+eleve["nom"]                 # "Alice"  (KeyError si absent)
+eleve.get("ville")           # None     (pas d'erreur)
+eleve.get("ville", "?")      # "?"      (valeur par défaut)
+eleve["ville"] = "Lyon"      # ajoute ou modifie
+del eleve["age"]             # supprime
+"nom" in eleve               # True (teste les clés)
+
+for cle, valeur in eleve.items():
+    print(cle, valeur)
+
+eleve.keys(), eleve.values()
+
+compte = {}
+compte["a"] = compte.get("a", 0) + 1     # compter des occurrences
+```
+
+---
+
+## 7. Fonctions (ch. 05)
+
+```python
+def aire_rectangle(largeur, hauteur=1):
+    """Renvoie l'aire d'un rectangle."""
+    return largeur * hauteur
+
+aire_rectangle(3, 4)                 # 12
+aire_rectangle(3)                    # 3  (hauteur par défaut)
+aire_rectangle(hauteur=2, largeur=5) # 10 (arguments nommés)
+
+def stats(*nombres, **options):      # nombre variable d'arguments
+    print(nombres, options)          # tuple, dict
+
+stats(1, 2, 3, arrondi=2)            # (1, 2, 3) {'arrondi': 2}
+
+def min_max(valeurs):
+    return min(valeurs), max(valeurs)  # renvoie un tuple
+
+petit, grand = min_max([4, 1, 9])
+```
+
+> **Piège** : ne jamais mettre une liste ou un dict comme valeur par défaut (`def f(x=[])`). Utilise `None` puis crée la liste dans la fonction.
+
+---
+
+## 8. Chaînes de caractères (ch. 06)
+
+```python
+s = "  Bonjour le Monde  "
+
+s.strip()                    # "Bonjour le Monde"
+s.lower(), s.upper()         # minuscules, majuscules
+s.title()                    # "  Bonjour Le Monde  "
+s.replace("Monde", "monde")
+s.split()                    # ["Bonjour", "le", "Monde"]
+"a,b,c".split(",")           # ["a", "b", "c"]
+"-".join(["a", "b", "c"])    # "a-b-c"
+s.strip().startswith("Bon")  # True
+"monde" in s.lower()         # True
+s.count("o")                 # 3
+s.find("le")                 # indice, ou -1 si absent
+"42".isdigit()               # True
+
+mot = "Python"
+mot[0], mot[-1]              # "P", "n"
+mot[1:4]                     # "yth"
+mot[::-1]                    # "nohtyP" (inversé)
+```
+
+---
+
+## 9. Compréhensions et outils d'itération (ch. 06)
+
+```python
+carres = [x ** 2 for x in range(5)]              # [0, 1, 4, 9, 16]
+pairs = [x for x in range(10) if x % 2 == 0]     # [0, 2, 4, 6, 8]
+longueurs = {mot: len(mot) for mot in ["a", "abc"]}  # {'a': 1, 'abc': 3}
+uniques = {x % 3 for x in range(10)}             # {0, 1, 2}
+
+for i, fruit in enumerate(["a", "b"], start=1):  # 1 a / 2 b
+    print(i, fruit)
+
+for nom, note in zip(["Ana", "Léo"], [14, 12]):  # parcourt en parallèle
+    print(nom, note)
+
+sorted([3, 1, 2])                        # [1, 2, 3] (nouvelle liste)
+sorted(mots, key=len, reverse=True)      # trié par longueur décroissante
+sorted(eleves, key=lambda e: e["note"])  # trié selon une clé
+any(x > 5 for x in valeurs)              # au moins un ?
+all(x > 0 for x in valeurs)              # tous ?
+```
+
+---
+
+## 10. Fichiers, CSV, JSON (ch. 07)
+
+```python
+from pathlib import Path
+
+# Texte
+with open("notes.txt", "w", encoding="utf-8") as f:   # w = écrase
+    f.write("Première ligne\n")
+with open("notes.txt", "a", encoding="utf-8") as f:   # a = ajoute
+    f.write("Suite\n")
+with open("notes.txt", encoding="utf-8") as f:        # r par défaut
+    for ligne in f:
+        print(ligne.strip())
+
+chemin = Path("donnees") / "fichier.txt"
+chemin.parent.mkdir(exist_ok=True)
+chemin.write_text("bonjour", encoding="utf-8")
+chemin.read_text(encoding="utf-8")
+chemin.exists(), chemin.suffix, chemin.stem           # True, ".txt", "fichier"
+
+# CSV
+import csv
+with open("eleves.csv", "w", newline="", encoding="utf-8") as f:
+    ecrivain = csv.DictWriter(f, fieldnames=["nom", "note"])
+    ecrivain.writeheader()
+    ecrivain.writerow({"nom": "Ana", "note": 15})
+with open("eleves.csv", newline="", encoding="utf-8") as f:
+    for ligne in csv.DictReader(f):
+        print(ligne["nom"], int(ligne["note"]))
+
+# JSON
+import json
+donnees = {"nom": "Ana", "notes": [15, 12]}
+with open("data.json", "w", encoding="utf-8") as f:
+    json.dump(donnees, f, ensure_ascii=False, indent=2)
+with open("data.json", encoding="utf-8") as f:
+    donnees = json.load(f)
+```
+
+---
+
+## 11. Exceptions (ch. 08)
+
+```python
+try:
+    nombre = int(input("Nombre : "))
+    resultat = 100 / nombre
+except ValueError:
+    print("Ce n'est pas un nombre.")
+except ZeroDivisionError:
+    print("Division par zéro impossible.")
+else:
+    print(f"Résultat : {resultat}")     # si aucune erreur
+finally:
+    print("Toujours exécuté")
+
+if age < 0:
+    raise ValueError("L'âge ne peut pas être négatif")
+
+class SoldeInsuffisant(Exception):     # exception personnalisée
+    pass
+
+breakpoint()                           # met le programme en pause (débogueur)
+```
+
+---
+
+## 12. Modules utiles (ch. 09)
+
+```python
+import random
+random.randint(1, 6)            # entier entre 1 et 6 inclus
+random.choice(["a", "b"])       # élément au hasard
+random.shuffle(liste)           # mélange sur place
+
+import math
+math.sqrt(16), math.pi, math.ceil(2.1), math.floor(2.9)   # 4.0, 3.14…, 3, 2
+
+from datetime import date, datetime, timedelta
+date.today()
+datetime.now().strftime("%d/%m/%Y %H:%M")
+date(2026, 12, 25) - date.today()       # timedelta
+date.today() + timedelta(days=7)
+
+from collections import Counter, defaultdict
+Counter("abracadabra").most_common(2)   # [('a', 5), ('b', 2)]
+groupes = defaultdict(list)
+
+import os, sys
+os.getcwd()                             # dossier courant
+sys.argv                                # arguments de la ligne de commande
+
+# Dans ses propres modules :
+if __name__ == "__main__":
+    main()      # exécuté seulement si on lance ce fichier directement
+```
+
+---
+
+## 13. Classes (ch. 10 et 11)
+
+```python
+class Compte:
+    taux = 0.02                          # attribut de classe (partagé)
+
+    def __init__(self, titulaire, solde=0):
+        self.titulaire = titulaire       # attributs d'instance
+        self.solde = solde
+
+    def deposer(self, montant):
+        if montant <= 0:
+            raise ValueError("Montant invalide")
+        self.solde += montant
+
+    def __str__(self):                   # affichage pour l'utilisateur
+        return f"{self.titulaire} : {self.solde} €"
+
+    def __repr__(self):                  # affichage pour le développeur
+        return f"Compte({self.titulaire!r}, {self.solde})"
+
+
+class CompteEpargne(Compte):             # héritage
+    def __init__(self, titulaire, solde=0, plafond=10_000):
+        super().__init__(titulaire, solde)
+        self.plafond = plafond
+
+
+c = CompteEpargne("Ana", 100)
+c.deposer(50)
+print(c)                                 # Ana : 150 €
+isinstance(c, Compte)                    # True
+```
+
+**Dataclass et propriété**
+
+```python
+from dataclasses import dataclass, field
+
+@dataclass
+class Produit:
+    nom: str
+    prix: float
+    tags: list[str] = field(default_factory=list)
+
+    @property
+    def prix_ttc(self) -> float:          # s'utilise comme un attribut
+        return round(self.prix * 1.2, 2)
+
+p = Produit("Stylo", 2.5)
+p.prix_ttc                                # 3.0
+```
+
+---
+
+## 14. Annotations de type (ch. 11)
+
+```python
+def moyenne(notes: list[float]) -> float:
+    return sum(notes) / len(notes)
+
+def trouver(nom: str, annuaire: dict[str, str]) -> str | None:
+    return annuaire.get(nom)
+
+age: int = 30
+coordonnees: tuple[float, float] = (45.19, 5.72)
+```
+
+> Les annotations ne changent pas l'exécution : elles documentent le code et permettent à l'éditeur et à `mypy` de détecter des erreurs.
+
+---
+
+## 15. Commandes du terminal (ch. 00, 12, 13)
+
+**Python et paquets**
+
+| Action | macOS / Linux | Windows |
+|---|---|---|
+| Lancer un script | `python3 script.py` | `py script.py` ou `python script.py` |
+| Version | `python3 --version` | `py --version` |
+| Créer un venv | `python3 -m venv .venv` | `py -m venv .venv` |
+| Activer le venv | `source .venv/bin/activate` | `.venv\Scripts\Activate.ps1` |
+| Désactiver | `deactivate` | `deactivate` |
+| Installer un paquet | `pip install requests` | `pip install requests` |
+| Figer les dépendances | `pip freeze > requirements.txt` | idem |
+| Réinstaller | `pip install -r requirements.txt` | idem |
+| Lancer les tests | `pytest` | `pytest` |
+| Vérifier / formater | `ruff check .` / `ruff format .` | idem |
+
+**Navigation**
+
+| Action | macOS / Linux | Windows (PowerShell) |
+|---|---|---|
+| Où suis-je ? | `pwd` | `pwd` |
+| Lister | `ls` | `ls` ou `dir` |
+| Changer de dossier | `cd dossier` / `cd ..` | idem |
+| Créer un dossier | `mkdir nom` | idem |
+
+**Git**
+
+```bash
+git init                         # créer un dépôt
+git status                       # état des fichiers
+git add fichier.py               # préparer (ou git add .)
+git commit -m "Message clair"    # enregistrer une version
+git log --oneline                # historique
+git diff                         # voir les modifications
+git switch -c nouvelle-branche   # créer une branche et y aller
+git switch main                  # revenir sur main
+git merge nouvelle-branche       # fusionner
+git remote add origin URL        # lier à GitHub
+git push -u origin main          # envoyer
+git pull                         # récupérer
+git clone URL                    # copier un dépôt existant
+```
+
+---
+
+## 16. Erreurs courantes et leur sens
+
+| Erreur | Signification | Cause typique |
+|---|---|---|
+| `SyntaxError` | Python ne comprend pas la ligne | `:` oublié, parenthèse non fermée, guillemet manquant |
+| `IndentationError` | Indentation incorrecte | Mélange tabulations/espaces, bloc mal aligné |
+| `NameError: name 'x' is not defined` | Nom inconnu | Faute de frappe, variable utilisée avant d'être créée |
+| `TypeError` | Opération impossible sur ce type | `"âge : " + 30`, mauvais nombre d'arguments |
+| `ValueError` | Bon type, mauvaise valeur | `int("abc")` |
+| `IndexError: list index out of range` | Indice trop grand | `liste[len(liste)]` |
+| `KeyError` | Clé absente du dictionnaire | `d["cle"]` au lieu de `d.get("cle")` |
+| `AttributeError` | Attribut ou méthode inexistant | `liste.push()` au lieu de `append()`, variable à `None` |
+| `ZeroDivisionError` | Division par zéro | Diviseur non vérifié |
+| `FileNotFoundError` | Fichier introuvable | Mauvais chemin, script lancé depuis un autre dossier |
+| `ModuleNotFoundError` | Module introuvable | Paquet non installé, venv non activé |
+| `RecursionError` | Trop d'appels récursifs | Cas de base manquant |
+
+> **Règle d'or** : lis toujours un traceback **de bas en haut**. La dernière ligne dit *quoi*, les lignes au-dessus disent *où*.
+
+---
+
+[← Projet final](15-projet-final.md) | [Sommaire](README.md) | [Ressources →](ressources.md)

docs/presentations/Python/ressources.md

@@ -0,0 +1,104 @@
+# Ressources pour continuer à apprendre
+
+Une sélection de ressources fiables, classées par usage. Les ressources en français sont signalées par 🇫🇷 ; les autres sont en anglais, mais souvent faciles à suivre avec un traducteur.
+
+> **Conseil** : ne cherche pas à tout consulter. Choisis **une** ressource principale par étape et complète avec de la pratique. Accumuler les tutoriels sans coder est le piège le plus courant.
+
+---
+
+## Documentation officielle
+
+| Ressource | Pour quoi faire |
+|---|---|
+| 🇫🇷 [Tutoriel officiel Python](https://docs.python.org/fr/3/tutorial/) | La référence, traduite en français. Idéal pour revoir une notion après le chapitre correspondant. |
+| 🇫🇷 [Bibliothèque standard](https://docs.python.org/fr/3/library/) | Tous les modules fournis avec Python (`random`, `datetime`, `pathlib`…). |
+| 🇫🇷 [Glossaire Python](https://docs.python.org/fr/3/glossary.html) | Quand un terme technique t'échappe. |
+| [PEP 8](https://peps.python.org/pep-0008/) | Les conventions d'écriture du code Python (vues au chapitre 13). |
+
+---
+
+## Outils pour comprendre son code
+
+| Outil | Pour quoi faire |
+|---|---|
+| [Python Tutor](https://pythontutor.com/) | Visualise l'exécution ligne par ligne : variables, listes, appels de fonctions. Excellent pour les chapitres 03 à 05. |
+| Le débogueur de VS Code | Points d'arrêt et exécution pas à pas (chapitre 08). |
+
+---
+
+## Cours et livres
+
+### Pour débuter
+
+- 🇫🇷 **Apprendre à programmer avec Python 3**, Gérard Swinnen — un classique, disponible gratuitement en PDF sur [le site de l'auteur](https://inforef.be/swi/python.htm) et en version papier chez Eyrolles.
+- 🇫🇷 **OpenClassrooms** — cours d'initiation à Python, gratuits en ligne.
+- 🇫🇷 **Zeste de Savoir** — tutoriels Python rédigés par la communauté, et un forum d'entraide.
+- **Python Crash Course**, Eric Matthes — progression très claire, avec trois projets (jeu, data, web) en seconde partie.
+- **Automate the Boring Stuff with Python**, Al Sweigart — gratuit en ligne sur [automatetheboringstuff.com](https://automatetheboringstuff.com/). Parfait pour l'automatisation (chapitre 14).
+- **Think Python**, Allen Downey — gratuit en ligne, plus orienté « penser comme un programmeur ».
+
+### Pour progresser
+
+- **Real Python** ([realpython.com](https://realpython.com/)) — articles et tutoriels de qualité sur à peu près tous les sujets.
+- **Fluent Python**, Luciano Ramalho — pour comprendre Python en profondeur une fois les bases solides (à garder pour après le cours).
+- **Effective Python**, Brett Slatkin — des dizaines de bonnes pratiques concrètes.
+
+---
+
+## Plateformes d'exercices
+
+| Plateforme | Niveau | Particularité |
+|---|---|---|
+| 🇫🇷 [France-IOI](https://www.france-ioi.org/) | Débutant → avancé | Exercices très progressifs, en français, avec correction automatique |
+| [Exercism](https://exercism.org/tracks/python) | Débutant → intermédiaire | Exercices gratuits avec possibilité de retours de mentors bénévoles |
+| [Codewars](https://www.codewars.com/) | Tous niveaux | Petits défis (« kata ») classés par difficulté ; on voit ensuite les solutions des autres |
+| [CodinGame](https://www.codingame.com/) | Tous niveaux | Puzzles et jeux de programmation, ludique |
+| [Advent of Code](https://adventofcode.com/) | Intermédiaire | 25 problèmes chaque décembre ; les archives des années passées restent disponibles |
+| [Project Euler](https://projecteuler.net/) | Intermédiaire → avancé | Problèmes mathématiques à résoudre par le code |
+
+> **Méthode** : après avoir résolu un exercice, lis deux ou trois solutions d'autres personnes. C'est l'un des meilleurs moyens d'apprendre de nouvelles façons d'écrire du code.
+
+---
+
+## Par spécialisation (chapitre 14)
+
+| Domaine | Point de départ |
+|---|---|
+| Automatisation | *Automate the Boring Stuff with Python* ; documentation de `pathlib`, `requests`, `openpyxl` |
+| Web | Tutoriel officiel de Flask, tutoriel de Django (« Écrire sa première application Django », traduit en français), documentation de FastAPI |
+| Data | Guide « 10 minutes to pandas » dans la documentation de pandas ; cours gratuits de Kaggle Learn |
+| IA / Machine learning | Tutoriels de scikit-learn ; Kaggle Learn ; cours gratuits de fast.ai pour le deep learning |
+| Jeux | Documentation et tutoriels de pygame ; Arcade, une autre bibliothèque de jeux 2D |
+
+---
+
+## Communautés et entraide
+
+- 🇫🇷 **AFPy** ([afpy.org](https://www.afpy.org/)) — l'Association Francophone Python, avec un forum, des offres d'emploi et l'organisation de la PyConFR.
+- 🇫🇷 **Forum de Zeste de Savoir** — section programmation, bienveillante avec les débutants.
+- **r/learnpython** sur Reddit — très actif, questions de débutants bienvenues.
+- **Stack Overflow** — l'immense majorité des messages d'erreur y a déjà une réponse ; cherche avant de poster.
+- **Meetups Python locaux** — beaucoup de grandes villes ont des rencontres régulières ; regarde sur Meetup ou sur le site de l'AFPy.
+
+### Bien poser une question
+
+Une bonne question obtient une réponse rapide. Elle contient :
+
+1. **Ce que tu veux faire** (le but, pas seulement le problème technique).
+2. **Le code minimal** qui reproduit le problème, formaté comme du code.
+3. **Le message d'erreur complet**, copié-collé (pas une capture d'écran).
+4. **Ce que tu as déjà essayé.**
+5. Ta version de Python et ton système d'exploitation si c'est pertinent.
+
+---
+
+## Rester motivé
+
+- **Code sur des sujets qui t'intéressent** : un script pour ta passion, ton travail, tes jeux. La motivation intrinsèque est le meilleur carburant.
+- **Garde une trace de tes progrès** : un dépôt GitHub qui se remplit est très encourageant à regarder après quelques mois.
+- **Accepte d'être bloqué** : c'est l'état normal d'un programmeur, même expérimenté. Chaque bug résolu est une compétence acquise.
+- **Explique ce que tu apprends** à quelqu'un d'autre (ou à un canard en plastique). Si tu peux l'expliquer simplement, tu l'as compris.
+
+---
+
+[← Aide-mémoire](aide-memoire.md) | [Sommaire](README.md)