Licence CC BY

De la difficulté d'écrire un cours Python pour débutants

Un jour ce cours viendra ♫

Dernière mise à jour :
Auteur :
Catégorie :
Temps de lecture estimé : 31 minutes

Ont déjà été tentées , ici, ou encore , différentes approches pour apporter sur ZesteDeSavoir un cours d’apprentissage du Python pour débutants. Aucune n’a réussi. Comme évoqué dans ce sujet, il s’agit d’un exercice difficile.

C’est pourtant un défi que j’aimerais relever, parce que je trouve l’existant actuellement insuffisant. Ma préférence va vers le cours « Apprendre à programmer avec Python » de Gérard Swinnen, qui a le mérite de s’orienter sur l’apprentissage de la programmation avec Python comme support, plutôt que l’inverse. Mais qui du même coup ne donne pas un bon enseignement des structures du langage (itérations), et qui se porte très vite sur l’aspect graphique (Tkinter).

J’ai alors voulu synthétiser tout ce qui pourrait servir à la rédaction future d’un tel cours. La ligne directrice à suivre, les notions à aborder, les autres apprentissages, et les obstacles qui seront rencontrés au long de la rédaction.

Les notions

Le plus simple à mes yeux est de dresser la liste des notions du langage, elles sont pour moi assez claires. La liste qui suit ne représente pas un ordre particulier dans lequel seraient abordées les notions.

  • Il y aurait premièrement les types de données « de base » : nombres entiers, flottants, chaînes de caractères (+ bytes), listes, tuples, dictionnaires et ± ensembles. Avec leurs méthodes et les opérateurs qui s’y appliquent, les priorités de ces opérateurs ;
  • Il y aurait aussi les structures du langage : variables, conditions (± ternaires), boucles while et for, fonctions, imports, exceptions et gestionnaires de contexte (utilisation) ;
  • Il faudrait décrire la bibliothèque standard (builtins), ses principaux modules (os, os.path/pathlib, sys, math, random, ± pickle, ± réseau) ;
    • Ce qui passerait par de la manipulation de fichiers, de la gestion des paramètres de la ligne de commande (argparse).

Mais tout ça sans parler des points essentiels et rébarbatifs, qui ne sont pas des notions à proprement parler, mais les premiers points bloquants que rencontrera un débutant :

  • Procédures d’installation de l’interpréteur (avec précisions sur l’OS, sur la version à choisir) ;
  • Prise en main de la console, découverte de l’interpréteur interactif ;
  • Choix, installation et prise en main d’un éditeur de texte ;
  • Écriture du code dans des fichiers (shebang, encodages) ;
  • Outils annexes (pip, environnement virtuels), installation de bibliothèques complémentaires ;
  • Partage/distribution d’un programme.

Maintenant, avec l’ensemble de ces points plus une présentation du langage, de ses intérêts et de son histoire, je trouve qu’on commence à avoir un périmètre assez précis.

L'articulation

Reste alors le plus difficile :

  • Mettre cela en forme en ayant une ligne suffisamment intéressante pour ne pas perdre le lecteur ;
  • Ne pas tomber dans la facilité avec une description du langage, mais bien enseigner la programmation ;
  • Rester constamment juste, la moindre erreur pouvant avoir de fortes implications ;
  • Cela exclut aussi d’énoncer des choses fausses dans les premiers chapitres pour les corriger par la suite ;
  • Être ludique.

Il faut en effet que le lecteur apprenne, que cet apprentissage soit progressif, et donc qu’il s’exerce. Je suis assez favorable à l’idée d’un exercice en tant que fil conducteur, mais la diversité des points à aborder peut parfois se heurter à la réalisation d’une application unique.

Le plus dur pour moi est d’accepter que toutes les informations sur un mot-clef, un type ou une fonction ne pourront pas être centralisées dans un même chapitre : il ne s’agit pas de rédiger une documentation ! Il faut alors penser à un découpage adéquat, un mélange subtil et de bonnes liaisons pour aborder les notions au fur et à mesure.

Élaboration d'un plan

Chapitres de présentation et découverte

Il est évident qu’il faudra débuter par la présentation du langage et l’installation de son interpréteur. Mais je pense qu’il est nécessaire de placer le plus d’informations possibles dans des chapitres annexes (installation de l’interpréteur, d’un éditeur de texte, prise en main de l’éditeur), et d’y faire seulement référence dans le fil principal, afin de ne pas l’alourdir (un utilisateur de Linux n’a que faire de l’installation de Python sous Windows, par exemple).

Ce premier chapitre devra aussi aborder la question des différentes versions de Python. Et montrer un éventail de ce qu’il est possible de réaliser avec ce langage.

Viendra ensuite la prise en main de l’interpréteur, avec des expressions basiques. Classiquement, on retrouve une utilisation de l’interpréteur interactif en mode calculatrice. Ça a le mérite de présenter un type simple (nombres entiers) et quelques opérateurs : il est ensuite facile de commencer à aborder le principe des variables. L’autre avantage est de permettre, par l’opérateur de division, une transition simple des nombres entiers vers les flottants.

Avant d’aller plus loin, il faut encore présenter l’utilisation de fichiers pour écrire son code, et le lancement de l’interpréteur sur un tel fichier. Il est alors nécessaire d’aborder la fonction print. Et impossible de faire l’impasse sur les questions d’encodage, notamment pour les utilisateurs de Windows.

Il serait aussi assez juste d’expliquer quand utiliser l’interpréteur interactif, et quand préférer l’écriture dans un fichier.

D’autres fonctions comme abs, round, min et max pourraient aussi être présentées dans ces premiers chapitres.

La question du fil conducteur

Arrivé ici, le lecteur a appris à lancer Python, et sait un minimum interagir avec lui. C’est maintenant qu’un fil conducteur devient primordial : il faut que notre lecteur trouve un intérêt à continuer sa lecture. Ce fil déterminera dans quel ordre seront abordées les notions. Comme dit plus tôt, j’aime l’idée d’une application qui serait développée tout le long du cours, et qui serait consolidée par chaque nouvelle notion.

Le cours tel que je l’imagine ne proposerait rien sur la programmation graphique. J’exclus alors toute application qui aurait pour but d’obtenir une interface graphique, et qui serait plutôt décevante sans. Ça appuie par contre l’idée qu’il faudrait un second cours, à la suite de ce premier, sur la prise en main d’une bibliothèque graphique1.

Pour l’aspect ludique, je pense qu’il est préférable de s’orienter vers un jeu. Et pour sa relative simplicité, je pense qu’un combat au tour par tour à la manière de Pokémon peut être une bonne idée.

Premiers types de données

Il est maintenant nécessaire de quitter les nombres et d’aborder les chaînes de caractères. Viennent alors de nouveaux opérateurs et de nouvelles fonctions (len). C’est probablement à partir d’ici que sera utilisé le terme « fonction ».

Puis il est temps d’introduire le concept de variables, leur utilité, leur définition et leur nomenclature. Leur spécificité en Python, aussi, pour les lecteurs qui auraient expérimenté d’autres langages. On noterait aussi les différents opérateurs d’affectation.

Peut ensuite être présentée la fonction input, pour de premières interactions avec l’utilisateur.

Quelques méthodes simples peuvent aussi être introduites : capitalize, upper, lower, index. C’est surtout la différence de syntaxe entre appels de fonctions et de méthodes qui doit être comprise.

À ce moment du cours, il est déjà possible d’avoir une application contenant 4 variables : les noms des deux combattants et leurs points de vie. Les noms peuvent même être demandés à l’utilisateur via input. L’introduction des conversions de type permettrait aussi de demander les PVs.

Le chapitre suivant portera nécessairement sur les conditions.

Premières structures de données

Les conditions vont permettre d’aller plus loin dans les interactions avec l’utilisateur, en lui proposant des choix par exemple. Seront aussi abordés les opérateurs booléens (and, or et not), et par extension le type bool, dans un but de vérification des entrées utilisateurs (vérifier qu’un nombre est compris entre deux bornes). Ce dernier point permettra de présenter les inégalités chaînées en Python (a < b < c).

Il sera alors temps d’introduire les listes (listes d’attaques), leurs opérateurs (semblables aux str), et leurs méthodes (index, append). Un premier paragraphe pourra être émis sur la mutabilité (en référence aux chaînes de caractères).

Puis les listes serviraient à aborder les boucles for. Par exemple, itérer sur les attaques pour présenter les choix à l’utilisateur. Dans la foulée, on trouverait bien évidemment range. J’aurais aussi pensé à enumerate (pour éviter le recours trop fréquent à range), voire zip, mais ça fait peut-être un peu tôt.

Viendrait enfin la boucle while, pour faire tourner le jeu jusqu’à ce que l’un des deux combattants n’ait plus de PVs. Je ne sais pas s’il serait judicieux de tout de suite parler des mots-clef break et continue, mais il faudra les placer quelque part.

Retour sur les types

Ici, il faudra avant tout évoquer les dictionnaires, pour remplacer les multiples variables représentant un combattant (nom, points de vie, attaques). Quelques petites digressions montreraient comment utiliser des dictionnaires conjointement aux boucles, on aborderait aussi les méthodes keys, values et items.

Je pense que c’est aussi le bon endroit pour parler des tuples : la plupart des listes utilisées jusque là n’ont aucun intérêt à être modifiables (attaques et listes d’attaques).

À ce point du cours, le lecteur a face à lui un programme fonctionnel de combats au tour par tour.

Les fonctions

Il sera alors temps de factoriser le code, et de montrer comment écrire de nouvelles fonctions. C’est la nécessité de créer des fonctions qui devra d’abord être expliquée. La définition de premières fonctions (sans paramètres ni retours) ne devrait pas poser de problème.

Mais il se posera ensuite celui du scope de la fonction, une fois les paramètres et arguments évoqués. Un lecteur ne devra pas quitter ce chapitre sans avoir compris qu’un paramètre n’existe qu’à l’intérieur d’une fonction, mais que sa valeur provient de l’extérieur (par l’argument). Le modèle de représentation des variables en Python (étiquettes) pourra être rappelé ici, notamment pour évoquer le cas des objets mutables.

Les premières fonctions définies serviront à séparer les affichages d’informations de la logique du code.

Enfin, on s’intéressera aux retours de fonction, afin de pouvoir pleinement les utiliser, et ainsi factoriser les blocs de code en rapport avec les choix utilisateur. Un rappel sur les tuples pourra être présenté pour parler des retours multiples.

Les fichiers

Je pense qu’à ce stade, il serait bon de parler des fichiers, pour enregistrer l’état de la partie par exemple. Les chapitres concernés seraient progressifs : on commence par un simple fichier texte que l’on open/close, on passe ensuite par un bloc with, on gère les exceptions à l’ouverture/écriture.

Il est alors imaginable de commencer à explorer la bibliothèque standard : struct, pickle ou json pour les fichiers de sauvegarde (les deux premiers ont l’avantage de permettre de parler des fichiers en mode binaire et du type bytes). Serait alors introduit le mécanisme d’importation, et ses syntaxes.

J’évoquerais tout de suite la documentation et la fonction help. On verrait aussi les modules sys puis argparse, afin de recevoir un fichier de sauvegarde au lancement de notre programme.

La séparation de l’application en différents modules aurait aussi sa place ici. Et ces chapitres pourraient se terminer sur le __name__ et sa fameuse valeur '__main__'.

Et plus si affinités

Ici, on commencerait par de l’aléatoire pour agrémenter un peu le jeu.

Mais les chapitres de cette partie serviraient aussi à présenter ce qui n’a pas pu l’être jusque là :

  • Les listes d’arguments (*args, **kwargs) ;
  • Les valeurs par défaut des paramètres de fonctions ;
  • Les autres méthodes des types de données basiques ;
  • Les autres types de données (ensembles, collections) ;
  • La gestion de types (type, isinstance) ;
  • Les conditions ternaires ;
  • Les mots-clef manquant (else, finally, break, continue, raise) ;
  • L’utilisation des décorateurs ;
  • La variable _ ;
  • Un peu de réseau si besoin ;
  • Les modules tiers, leur installation, les environnements virtuels, pip.

Cette dernière partie reprendrait une structure un peu plus documentaire : un chapitre consacré à un sujet, et qui fait le tour de la question.


  1. Celui-ci, par exemple. 

Le plan

Voici donc le plan qui pourrait ressortir des idées listées plus haut. Les titres correspondent à des parties, et les puces de plus haut niveau aux chapitres. Les noms ne sont là qu’à titre indicatif.

Je conviens que la dernière partie est très brouillonne, et devrait être revue de fond en comble et redécoupée. J’ai voulu y détailler ce qu’il était encore nécessaire de voir avant de passer à la suite (aux autres cours), tout en étant facultatif pour le lecteur « pressé ». On y trouve donc plus des chapitres à la clef.

Si je compte bien, on arrive actuellement à 7 parties pour 52 chapitres (de tailles variables), sans compter les annexes. C’est plutôt colossal :-°


Découverte

  • Présentation du langage
    • Histoire
    • Réalisations (ce qu’il est possible d’en faire)
    • Versions, interpréteurs
  • Installation
    • Redirection vers des chapitres annexes
    • Installation de l’interpréteur CPython 3.x
    • Installation d’un éditeur de texte + configuration
  • Prise en main
    • Lancement de l’interpréteur interactif
    • Expressions basiques (calculatrice), nombres entiers
    • Division, nombres flottants
  • Écriture du code dans des fichiers
    • Lancement de l’interpréteur sur un fichier
    • shebang, encodage du fichier
    • print
  • Que choisir entre REPL et fichiers ?

Interagir avec Python

  • Retour sur la calculatrice
    • Vue d’ensemble des opérateurs (division entière, modulo, puissance)
    • Fonctions (introduites en tant que telles) : abs, round, min, max
  • Sauvegarder un résultat : les variables
    • Poser une étiquette sur une valeur
    • Redéfinition d’une étiquette
    • Opérateurs d’affectation
    • Variable spéciale _
  • Les chaînes de caractères
    • Représenter autre chose que des nombres
    • Guillemets simples et doubles
    • La fonction len
    • Opérateurs des chaînes de caractères
      • Concaténation
      • Indexation
      • Slicing
  • Interagir avec l’utilisateur
    • La fonction input
    • Les conversions de type (types en tant que fonctions)
  • Les méthodes des objets
    • Introduction brève du concept d’objet
    • Différence entre fonctions et méthodes
    • Les méthodes des chaînes de caractères : capitalize, upper, lower, index
  • Mise en pratique : jeu de combat en tour par tour
    • Définir deux monstres : avec noms et points de vie
    • Définition au runtime : avec input
    • Attaque unique qui ferait perdre un nombre fixe de PVs
    • Un seul tour de jeu

Des programmes moins déterminés

  • Les conditions
    • Réaliser une action seulement si un test est vérifié
      • Tester une égalité (==)
    • Blocs de code et indentation
    • Clause else
    • Clauses elif
  • Les expressions booléennes
    • Notion de prédicat
    • Opérateurs de comparaison (==, !=, <, >, <=, >=)
    • Combiner les prédicats avec les opérateurs booléens (and, or, not)
    • True et False, tables de vérité
    • Toutes les valeurs correspondent à un booléen
    • Égalités et inégalités chaînées (a == b == c, a < b < c)
  • Ajoutons des conditions à notre jeu
    • Proposer à l’utilisateur de choisir les attaques
    • Les attaques ne seraient pas définies en tant que tel, mais seraient juste des blocs conditionnels
  • Les listes
    • Tableaux de valeurs de types divers (entiers, flottants, chaînes, booléens)
    • Listes d’attaques (une liste pour les noms, une pour les puissances)
    • Opérateurs et premières méthodes (index, count)
    • Les listes sont modifiables (contrairement aux chaînes)
    • Autres méthodes (append, insert, pop, clear)
    • Des listes dans des listes
    • Une liste unique pour les attaques
  • Itérer sur les valeurs d’une liste
    • La boucle for
      • for element in liste
    • Type range : itérer sur des nombres
    • Fonctions d’itérations : enumerate, zip
  • Intégration des boucles for dans le jeu
    • Itérer sur les attaques pour les proposer au joueur
    • Utiliser l’index retourné par input pour localiser la bonne attaque
  • Boucler sur une condition
    • La boucle while
    • Différence entre for et while (entre itérer et boucler)
    • Usages de la boucle while (condition de fin : calculs, attentes)
  • Un jeu qui tourne jusque la fin
    • Utiliser une boucle while pour continuer le jeu tant que l’un des deux monstres a des PVs

Retour sur les types

  • Rappel des types étudiés jusqu’ici
  • Méthodes
    • str.replace
    • list.extend, list.reverse, list.sort
  • Les dictionnaires
    • Tables d’association (associer des chaînes à d’autres valeurs)
    • Une variable unique pour représenter un monstre
    • Opérateurs des dictionnaires (accès aux éléments)
    • Les dictionnaires sont modifiables
    • Méthodes des dictionnaires : get, pop, update, clear
  • Itérer sur un dictionnaire
    • Les dictionnaires peuvent s’utiliser avec for
    • Méthodes keys, values et items
  • Clefs de dictionnaires
    • Les chaînes de caractères ne sont pas le seul type de clefs possible
    • Restriction sur les types de clefs (listes)
  • Tuples
    • Des listes non modifiables
    • Remplaçons nos listes par des tuples
    • Des tuples comme clefs de dictionnaires

Les fonctions

  • Factorisation du code
    • Don’t Repeat Yourself
    • Comment éviter ces répétitions et réunir les portions logiques ?
  • Définition d’une fonction
    • def toto():
    • Le code écrit dans le bloc n’est pas exécuté
    • À moins d’appeler la fonction
    • Une fonction peut être appelée plusieurs fois, le code sera chaque fois exécuté
  • Scope des fonctions
    • Les variables définies dans une fonction n’existent qu’à l’intérieur de celle-ci
    • Passer des valeurs via les arguments et paramètres
    • Les paramètres sont des variables de la fonction, il n’existent que dans son scope
    • Les arguments sont les valeurs qui existent à l’extérieur
    • Arguments positionnels et arguments nommés
  • Paramètres et types mutables
    • Attention, la modifiction d’un paramètre altère l’argument
    • Redéfinition n’est pas modification
  • Intégration des fonctions dans notre application
    • Regrouper les commandes d’affichage, paramétrées
  • Retours de fonctions
    • Renvoyer une valeur de l’intérieur vers l’extérieur
    • Le mot-clef return
    • Récupérer la valeur renvoyée
    • Renvoyer des valeurs multiples (tuples implicites)
    • Affectations multiples
    • Swap de variables

Utilisation de fichiers

  • Comment couper une partie pour la reprendre plus tard ?
  • Lire un fichier en Python
    • Fonction open
    • Mode 'r'
    • Méthodes read et close
    • Bloc with
  • Itérer sur un fichier
    • Argument de file.read
    • Méthodes readline et readlines
    • Itérer sur un fichier avec for
  • Écrire dans un fichier
    • Le mode 'w'
    • Méthodes write et writelines
    • Fonction print
    • Méthode seek
    • Le mode 'a'
  • Les modules
    • Notion de module
    • Module = fichier
    • Importer un module (import)
    • Extraire des données d’un module (from ... import)
    • Se documenter sur un module (help)
  • Gérer les exceptions
    • Le fichier n’existe pas forcément
    • Modules os et os.path
    • Tester la présence d’un fichier avec os.path.exists
    • Mieux : réagir en cas d’erreur
    • Blocs try/except
  • Formater les données
    • Module json
    • Ouverture des fichiers en mode binaire
    • Le type bytes
    • Module pickle
  • Arguments de la ligne de commande
    • Recevoir le fichier à traiter par la ligne de commande
    • Le module sys, sys.args
    • Utilisation avancée : le module argparse
  • Séparons notre application en modules
    • Découpage et factorisation
    • Notion de packages
    • __name__

Aller plus loin

  • Un peu d’aléatoire
    • Le module random
    • Choisir un nombre : randint et randrange
    • Choisir un élément : choice, sample et shuffle
    • Simuler une IA dans notre jeu
    • Les nombres flottants et les distributions
  • Retour sur les chaînes de caractères
    • replace, split, join et autres méthodes
  • Les autres types de données
    • Ensembles (set)
    • Module collections
  • Retour sur les conditions
    • Instructions et expressions
    • Conditions ternaires
  • Retour sur les boucles
    • Boucles infinies
    • Couper une boucle : break
    • Passer à l’itération suivante : continue
    • else pour savoir comment s’est terminée une boucle
  • Retour sur les exceptions
    • Réagir quand tout va bien : else
    • Réagir dans tous les cas : finally
    • Lever une exception : raise
  • Débogage
    • Introspecter une valeur (help, dir, type)
    • Présentation de pdb
  • Tour d’horizon de la bibliothèque standard
  • Un peu de réseau
    • Introduction aux sockets (utilité, familles, types)
    • Architecture serveur (bind, listen, accept)
    • Architecture client (accept)
    • Envoyer et recevoir des messages
  • Programmation multi-threadée
    • Instancier des threads
    • Programmation concurrente
  • Installer des modules/paquets supplémentaires
    • Installation par le système d’exploitation
    • Installation via pip
    • Environnements virtuels
  • Transition vers le chapitre POO + bibliothèque graphique

Voilà pour ce qui est de mes idées sur le sujet. Je n’ai pas prévu de commencer la rédaction de ce cours, mais je garde ça dans un coin de la tête.

Les ressources actuelles évoquées en introduction seraient bien sûr réutilisées dans la mesure du possible, afin de ne pas réécrire l’existant.

Des avis, des remarques, des questions ?

20 commentaires

Je vais tenter de te donner mon feedback.

Déjà, parlons rapidement de moi :

Je suis ingénieur, pas dans le domaine de l’informatique, mais dans les faits, j’ai pas mal d’expérience en informatique (pas mal de C il y a de très nombreuses années, et du VBA, du SQL et PL/SQL dans le cadre professionnel et pas mal d’autres connaissances en informatique).

Mais en Python, rien dans le cadre professionnel, juste quelques toutes petites bricoles à titre personnel. J’ai donc installé Python sur mon micro perso il y a environ 1 an et demi, j’ai lu le fameux Swinnen, et je n’ai quasiment pas pratiqué depuis un an. Du coup, je suis à nouveau ’vierge’.

Mon ressentiment en lisant tout ce billet. *

a. - Tu dis en introduction un truc qui me parait essentiel : Ma préférence va vers le cours « Apprendre à programmer avec Python » de Gérard Swinnen, qui a le mérite de s’orienter sur l’apprentissage de la programmation avec Python comme support, plutôt que l’inverse.

C’est essentiel. Tu ne veux pas faire un cours sur python, mais un cours de programmation. Et j’aime beaucoup cette approche. Malheureusement, ce que je lis ensuite ne me semble pas cohérent avec cette promesse.

Dans cette optique, je pense que ce serait bien de procéder ainsi :

    • Description d’un concept dans la théorie (type de variable ou boucle ou test). Peu importe le langage à ce niveau.
    • Traduction de ce concept dans 2 ou 3 langages. (Python bien sûr, et un ou 2 autres langages, je pense à R et à VBA, mais c’est personnel). Eventuellement, les langages pris en exemple ne sont pas les mêmes à chaque leçon. Dans certains cas, on peut même avoir un exemple en Python2 et un en Python3, sachant que certaines syntaxes sont différentes.

Bien sûr, à partir du 3ème ou 4ème chapitre, ce n’est plus tenable, et il faut une transition très claire : Dans les chapitres suivants, On n’est plus dans un cours de programmation, mais dans un cours sur Python.

b. - Installer Python. Il y a déjà un tutoriel sur anaconda sur ZdS ; Je pense qu’il faut simplement un lien vers ce tutoriel.

c. - Quand tu rentres dans le dur, quand tu abordes les notions, tu parles très vite de tuples, de listes et de dictionnaires.

STOP !

Pour moi, ces notions sont à aborder dans le chapitre 10, 15, 20 … je ne sais pas, mais très tard. A priori, ta cible, ce sont des gens qui ne savent pas faire une boucle, qui vont donc apprendre à faire une simple boucle, des gens qui vont découvrir que a=a+1, c’est possible en programmation ; on est donc très loin de la notion de tuple.

Rappel : ton objectif n’est pas de faire un cours sur Python, mais sur la programmation. Quand on aborde la différence entre une liste et un tuple, c’est qu’on a déjà franchi beaucoup d’étapes.

Tu parles ensuite des boucles. Ok, C’est pour moi une des premières notions à présenter. Mais j’essaierai de parler des boucles for… faire un tour assez complet des boucles for, jusqu’à avoir 2 boucles for imbriquées ( exercice : afficher les tables de multiplication de tous les nombres entre 2 et 10)

Et dans un second temps, expliquer pourquoi on a aussi besoin de boucles while, et montrer la syntaxe de ces boucles while.

Tout ça en gardant en tête l’objectif : faire un cours de programmation, et utiliser python/xxxx/yyyy comme exemple.

J’arrête là mon feed-back. Je peux essayer d’aborder la suite si ça te dit.

+0 -0

b. - Installer Python. Il y a déjà un tutoriel sur anaconda sur ZdS ; Je pense qu’il faut simplement un lien vers ce tutoriel.

elegance

ça rend le tutoriel dépendant, ça implique de faire confiance à l’autre tuto en terme de contenu et de durée de vie, et de faire confiance au lecteur pour suivre ces liens.
C’est un choix, moi je suis plutôt pour, ça rend les tutos modulaires, suivant un peu la logique KISS.

c. - Quand tu rentres dans le dur, quand tu abordes les notions, tu parles très vite de tuples, de listes et de dictionnaires. […] Tu parles ensuite des boucles. Ok, C’est pour moi une des premières notions à présenter. Mais j’essaierai de parler des boucles for… faire un tour assez complet des boucles for, jusqu’à avoir 2 boucles for imbriquées ( exercice : afficher les tables de multiplication de tous les nombres entre 2 et 10)

elegance

sauf qu’une utilisation classique des boucles for, avec une syntaxe qui lui est dédié, c’est le parcours des conteneurs. Il faudrait alors introduire les conteneurs sans entrer dans le détail liste/tuple … ?

Sinon concernant le billet, j’ai lu rapidement (en diagonale), alors je vais pas trop me prononcer. Généralement j’aime bien insister sur ce qui est standard, et en Python c’est assez facile de perdre cette notion car pip masque un peu les installations (du coup c’est tout aussi simple d’utiliser une bibliothèque tierce que standard). Et bien sûr mettre en évidence les liens vers les ressources de référence du langage (site officiel / documentation). Bref, j’ai l’impression que c’était déjà prévu mais je signale juste que je trouve ça essentiel, donc un accent là dessus n’est pas de trop AMHA.

Ce n’est pas parce qu’ils sont nombreux à avoir tort qu’ils ont raison - Coluche

+0 -0

C’est essentiel. Tu ne veux pas faire un cours sur python, mais un cours de programmation. Et j’aime beaucoup cette approche. Malheureusement, ce que je lis ensuite ne me semble pas cohérent avec cette promesse.

elegance

Et comme je le dis, cette approche n’est pas très naturelle pour moi, j’ai plutôt tendance à partir sur une description/énumération type documentation.

Après, je doute de la nécessité de s’appuyer sur plusieurs langages, car ce n’est pas non plus un cours générique que j’imagine. Je souhaite un cours sur le Python, qui enseigne la programmation.

Les titres que je mets dans la section « élaboration du plan » correspondent plus ou moins au découpage en parties qu’aurait le tutoriel. Mais rien n’est défini au niveau des chapitres, et que pense que les notions élémentaires évoquées dans les premiers paragraphes seraient bien plus appuyées que les suivantes, il ne faut donc pas y voir une transition trop rapide entre concepts de bases et types plus avancés.

Mais effectivement, sur la fin, il y aura des chapitres consacrés exclusivement à Python, plutôt qu’à la programmation (pour découvrir le reste des bases du langage). Par contre, ce qui précède (des simples expressions arithmétiques jusqu’aux exceptions) n’aurait Python que comme support.

Pour ce qui est d’Anaconda, ça me gêne de rediriger le lecteur vers une installation non standard. C’est sûrement très pratique pour l’installation d’un environnement scientifique, mais je vois mal conseiller cela plutôt qu’un pacman -S python. Je ne crois pas qu’Anaconda soit dans les dépôts officiels de la moindre distribution Linux, c’est pour moi rédhibitoire.

Je peux essayer d’aborder la suite si ça te dit.

elegance

Je veux bien, oui.

Sinon concernant le billet, j’ai lu rapidement (en diagonale), alors je vais pas trop me prononcer. Généralement j’aime bien insister sur ce qui est standard, et en Python c’est assez facile de perdre cette notion car pip masque un peu les installations (du coup c’est tout aussi simple d’utiliser une bibliothèque tierce que standard). Et bien sûr mettre en évidence les liens vers les ressources de référence du langage (site officiel / documentation). Bref, j’ai l’impression que c’était déjà prévu mais je signale juste que je trouve ça essentiel, donc un accent là dessus n’est pas de trop AMHA.

leroivi

Oui, c’est bien comme ça que je vois les choses : s’en tenir à la bibliothèque standard. La fin montrerait comment installer d’autres paquets, mais le cours ne porterait pas sur l’utilisation de paquets tiers (peut-être juste un en guise d’exemple).

Pour ce qui est des références à la documentation, c’est aussi comme cela que j’ai l’habitude de fonctionner. On peut de plus espérer une traduction complète de la documentation en français.

Pour ce qui est d’Anaconda, ça me gêne de rediriger le lecteur vers une installation non standard. C’est sûrement très pratique pour l’installation d’un environnement scientifique, mais je vois mal conseiller cela plutôt qu’un pacman -S python. Je ne crois pas qu’Anaconda soit dans les dépôts officiels de la moindre distribution Linux, c’est pour moi rédhibitoire.

Je suis l’auteur du tuto en question, et je suis d’accord.

Si vous êtes sous Linux, il est probablement préférable de passer par votre gestionnaire de paquets.

Intro du tuto anaconda.

Dans mon environnement pro, la question ne se pose pas : j’ai plein de collègues sous Windows, je travaille sur des machines de calcul sur de vieux CentOS (coucou python 2.6) et je ne suis pas admin (même pas sur ma machine de travail). Anaconda m’a sauvé le mise plus d’une fois. Si c’est pour apprendre chez soi, en particulier sous Linux, c’est se compliquer la vie et faire pas standard, on est d’accord.


Pour le fait de présenter les structures de données avant les boucles, je trouve que c’est une idée intéressante. J’avais déjà vu ça dans le tuto de C++ de gbdivers ; je trouve ça intéressant car ça pousse aux bonnes pratiques.

J’imagine que ça doit mieux marcher pour certaines personnes, et moins pour d’autre, je ne connais pas de tuto terminé ayant suivi cette approche pour pouvoir juger (et encore moins de débutants ayant suivi de tel tuto pour connaitre leurs impressions).


P.S. : J’oubliais d’apporter une correction au titre, le bon serait plutôt : « De la difficulté d’écrire un cours Python pour débutants », quel que soit le domaine, avec les mêmes problèmes (que transmettre, comment, quels pièges, quel fil rouge, est-ce que les manières habituelles sont bonnes, etc).

Édité par Gabbro

Hier, dans le parc, j’ai vu une petite vieille entourée de dinosaures aviens. Je donne pas cher de sa peau.

+0 -0

Dans mon environnement pro, la question ne se pose pas : j’ai plein de collègues sous Windows, je travaille sur des machines de calcul sur de vieux CentOS (coucou python 2.6) et je ne suis pas admin (même pas sur ma machine de travail). Anaconda m’a sauvé le mise plus d’une fois. Si c’est pour apprendre chez soi, en particulier sous Linux, c’est se compliquer la vie et faire pas standard, on est d’accord.

Gabbro

Et pour une installation sous Windows pour un utilisateur lambda, tu en penses quoi ?

Pour le fait de présenter les structures de données avant les boucles, je trouve que c’est une idée intéressante. J’avais déjà vu ça dans le tuto de C++ de gbdivers ; je trouve ça intéressant car ça pousse aux bonnes pratiques.

Gabbro

C’est aussi par nécessité. Présenter le while avant le for, c’est aussi présenter de mauvaises utilisations du while (celles qui doivent être remplacées par des for ... in range(...)).

Et je trouve préférable de montrer un for avec autre chose qu’un range pour commencer.

P.S. : J’oubliais d’apporter une correction au titre, le bon serait plutôt : « De la difficulté d’écrire un cours Python pour débutants », quel que soit le domaine, avec les mêmes problèmes (que transmettre, comment, quels pièges, quel fil rouge, est-ce que les manières habituelles sont bonnes, etc).

Gabbro

Oui, il y a des choses assez génériques. Mais j’ai précisé Python, parce que c’est là-dessus que je veux orienter la discussion.

Et pour une installation sous Windows pour un utilisateur lambda, tu en penses quoi ?

Ça marche. Pas besoin de lui dire « Maintenant que tu as Python, va récupérer la bibliothèque truc-muche-chouette sur le site officiel / fais pip install truc-muche-chouette ». Toutes les bibliothèques dont un nouveau dans le monde python peut avoir besoin sont incluses (dans mon domaine, en tout cas, si tu veux faire du web, je ne suis pas sur que tu y trouves un intérêt).

Hier, dans le parc, j’ai vu une petite vieille entourée de dinosaures aviens. Je donne pas cher de sa peau.

+0 -0

Juste pour faire part d’ une émotion courante quand on debute : une sensation de lourdeur, d’ un truc chiant à accomplir, d’un bourre crane, pour un hypothétique résultat lointain. C’est ce qu’ on peut ressentir quand on aborde des concepts pas intuitif, et qu’on se tape toutes les erreurs possibles à la queu-leu-leu . Et on se dit, "putain, deux heures du mat’ et je comprend toujours que dalle,pour retourner sur un autre cours…et à 5 heures du mat’ rebelotte.

On présente 3-4 mini projets très différents les uns des autres. Des trucs qu’ on sent vraiment utile, qu’on a déjà hâte de savoir manipuler.Et puis on donne le liste de route des Clefs à maîtriser absolument pour atteindre ces objectifs. Ces Clefs sont elles mêmes de mini objectifs que l’on aborde via un triple cycle: mini-cours ; mini-exo ; mini-TP. Comme cela , Paddawan devient Jedi "en douceur".

Qu’est-ce qu’un jeune de 16-17 ans meurt d’ envie d’ apprendre ? Il voudra un minimum de graphisme. Pygcurse a l’ avantage d’offrir le minimum syndical tout en permettant de ne pas hypnotiser l’ élève sur des considérations esthétiques. Sinon, Thorpy permet d’ apporter des widgets tkinter sur pygame, c’est bien pratique. Le réseau c’est quand même super important. La POO y’en faut , le cours sur sametmax est une bonne base qu’on pourrait étoffer d’ exemples. Une base de donnée minimaliste c’est quand même génial. Introduire une pincée de SQLAlchemy. et aussi : gestion de fichiers,Les conversions de type, la gestion des exceptions, la sérialisation, itérer, des boucles imbriquées…

Faudrait toujours rendre bien visible l’ utilité directe et concrète de chaque effort. Plutôt que d’ écrire une bible intégrale, mieux vaut combler les vides du cours de Swinnen et autres ?

+0 -0

Qu’est-ce qu’un jeune de 16-17 ans meurt d’ envie d’ apprendre ? Il voudra un minimum de graphisme. Pygcurse a l’ avantage d’offrir le minimum syndical tout en permettant de ne pas hypnotiser l’ élève sur des considérations esthétiques. Sinon, Thorpy permet d’ apporter des widgets tkinter sur pygame, c’est bien pratique. Le réseau c’est quand même super important. La POO y’en faut , le cours sur sametmax est une bonne base qu’on pourrait étoffer d’ exemples. Une base de donnée minimaliste c’est quand même génial. Introduire une pincée de SQLAlchemy. et aussi : gestion de fichiers,Les conversions de type, la gestion des exceptions, la sérialisation, itérer, des boucles imbriquées…

buffalo974

Je suis d’accord qu’il faut que le lecteur (pas forcément jeune) trouve un intérêt au cours. Mais je ne pense pas que cet intérêt soit nécessairement graphique. De toute manière, il faut déjà réunir des connaissances avant de commencer une application graphique : ce tutoriel aurait pour but d’enseigner ces connaissances préalables.

Pour la POO, je pense que ça n’est pas à placer dans ce cours d’initiation.

Plutôt que d’ écrire une bible intégrale, mieux vaut combler les vides du cours de Swinnen et autres ?

buffalo974

Libre à toi.

Je suis assez aligné avec Buffalo974 ; le lecteur veut obtenir des résultats immédiats. Tout ça, parce que pour moi, la cible, c’est ’Python pour les nuls’. Si la cible, c’est ’Python pour les gens doués et motivés’, c’est autre chose.

Si on présente au lecteur des concepts qui risquent de lui paraître abstraits, on prend le risque de le perdre. C’est pour cela que je suggérais de reporter assez loin la présentation des tuples et des trucs comme ça.

Dans ma tête, on propose assez tôt la boucle for. On présente ces 2 boucles, l’une en C, et son équivalent en python, et on dit qu’elles donnent le même résultat :

1
2
3
for (i=0; i<10;i++) {
  print (  "%1 * 4 = %2 ", i, i*4) // Syntaxe correcte ? je ne sais plus.
}
1
2
for i in range (10):
    print(i , "* 4 = ", i*4)

Et à ce niveau, on n’en explique pas beaucoup plus. Le lecteur n’est pas frustré, il a créé quelque chose, il a créé une table de multiplication. (ce n’est pas sexy, mais c’est important d’obtenir des résultats concrets rapidement)

Puis nettement plus loin, on va revenir sur cette instruction for i in range(10).

On peut par exemple montrer ces 2 codes (l’un en C, l’autre en Python) :

1
2
3
4
for (i=0; i<10;i++) {
  if ( i==5 ) i = 7 ;
  print (  "%1 * 4 = %2 ", i, i*4) 
}
1
2
3
4
for i in range (10):
    if ( i == 5) :
        i = 7
    print(i , "* 4 = ", i*4)

On va bien sûr dire que cette façon de coder est mauvaise, on ne la montre que pour montrer les problèmes qu’elle engendre. Et on va dire que dans le code en C, ce code affiche 8 lignes, alors que le code python affiche 10 lignes.

Quoi, comment, surprise du lecteur … on propose au lecteur d’arrêter sa lecture pendant 10 minutes ou plus, pour essayer de comprendre ce qui se passe, … et on lui explique ce range(10), et on enchaîne sur les choses essentielles à savoir sur les listes…

+0 -0

J’ ai commencé avec le tuto de prolixe sur sdz, et le cours de swinnen. Je faisais toutes les erreurs et j’ étais sauvé par "les erreurs courantes en python" de nohar, et les forums. Ce qu’il me manquait et manque toujours, c’est des exo et des TP, parcequ’il y a toujours des trous et on tombe dedans et on abandonne le projet pendant 6 mois pour refaire le même scenario ailleurs.

De qu’on s’émancipe un peu, on est fortement attiré par tous ces modules super, et là c’est le far-west, on redécouvre des nouvelles erreurs encore plus dures à résoudre et avec moins de réponses.

C’est pas seulement un problème de lire la doc en anglais, c’est le probleme de tomber pile sur l’ exemple qui n’existe pas ou reste enfouis dans les méandres du net malgré consultation de stackoverflow : un coup de pub pour ce lien qui m’a pris un peu de temps https://github.com/IndexErrorCoders/Nectar_SO_python

Édité par buffalo974

+0 -0

Je suis assez aligné avec Buffalo974 ; le lecteur veut obtenir des résultats immédiats. Tout ça, parce que pour moi, la cible, c’est ’Python pour les nuls’. Si la cible, c’est ’Python pour les gens doués et motivés’, c’est autre chose.

elegance

Et c’est justement ce que je tente de proposer : des résultats concrets plutôt qu’un détail de fonctionnalités.

Si on présente au lecteur des concepts qui risquent de lui paraître abstraits, on prend le risque de le perdre. C’est pour cela que je suggérais de reporter assez loin la présentation des tuples et des trucs comme ça.

elegance

D’après mon plan, les tuples apparaîtraient pile au milieu : juste avant l’introduction des fonctions. Tu trouves ça encore trop précipité ?

Dans ma tête, on propose assez tôt la boucle for. On présente ces 2 boucles, l’une en C, et son équivalent en python, et on dit qu’elles donnent le même résultat :

elegance

Et dans la mienne, il faut présenter quelque chose sur lequel itérer avant de commencer à itérer, et le range me paraît être un mauvais exemple. Puis le for Python n’a pas grand chose à voir (si ce n’est rien du tout) avec celui du C.

C’est peut-être justement par rapprochement avec le C que beaucoup de cours présentent un for ... in range(...), mais est-ce vraiment le cas d’usage de base ? À quel moment un débutant se dit-il « tiens, j’aimerais bien itérer sur un intervalle de nombres » ?

Et c’est prendre les choses à l’envers : c’est parce que le for est fait ainsi qu’on peut avoir l’objet range et itérer dessus. Présenter for comme une boucle pour itérer sur des nombres, c’est prendre le risque que le lecteur utilise range pour itérer sur une liste.

De plus, je ne conçois pas de mettre des bouts de code en C dans un tel cours. C’est inutilement compliqué (la syntaxe du for n’est facile à comprendre), surtout si tu commences à mixer ça avec les flags de formatage printf (qui sont effectivement faux dans ton exemple).

On va bien sûr dire que cette façon de coder est mauvaise, on ne la montre que pour montrer les problèmes qu’elle engendre. Et on va dire que dans le code en C, ce code affiche 8 lignes, alors que le code python affiche 10 lignes.

elegance

Mais je ne pense pas judicieux de présenter quelque chose d’incorrect, pour revenir dessus ensuite (pour peu que le lecteur lise la suite).

Pour citer Gabbro sur un autre sujet :

J’ai lu très en diagonal, mais j’ai une remarque importante sur la partie Exemples : tous ceux qui ont déjà donné des cours te le diront, si tu dis « faites A, ne faites pas B », les deux tiers des gens feront B (parce qu’ils connaissaient déjà, parce tu as mis l’emphase dessus…).

Gabbro

J’ ai commencé avec le tuto de prolixe sur sdz, et le cours de swinnen. Je faisais toutes les erreurs et j’ étais sauvé par "les erreurs courantes en python" de nohar, et les forums. Ce qu’il me manquait et manque toujours, c’est des exo et des TP, parcequ’il y a toujours des trous et on tombe dedans et on abandonne le projet pendant 6 mois pour refaire le même scenario ailleurs.

buffalo974

Et penses-tu que c’était une bonne chose de faire toutes ces erreurs et de n’en trouver les réponses que sur un sujet du forum ?

Le cours de Gérard Swinnen est plutôt bourré d’exercices, qu’est-ce qui manquait à ton avis ?

Édité par entwanne

Et penses-tu que c’était une bonne chose de faire toutes ces erreurs et de n’en trouver les réponses que sur un sujet du forum ?

entwanne

Je ne m’exprime pas sur le reste, mais… la je ne suis pas du tout d’accord, si on lit un tuto dans le but d’apprendre pour moi il faut que le lecteur essaie ses propres variantes "et si je faisais comme sa plutôt" "mon objectif à moi c’est sa, il faudrai peut-être que j’ajoute sa pour que sa marche", bref, cela fait que l’on sort des clous du tuto, et quand bien même on n’en sortirai pas on va se planter quelque par.

Faire des erreurs quand on apprend, c’est normal, et comme chacun fait lui même; s’il y a certes des erreurs fréquente il y a finalement autant de façon de se planté qu’il n’y a de lecteur du tuto.

On ne peu donc pas inclure l’ensemble des solutions dans le tutoriel…

Autrement dit, si on ne trouve pas la solution directement dans le tuto ou directement par soie même, il faut faire une recherche et allez là où les résultats nous conduisent

#JeSuisArius

+0 -0

si on lit un tuto dans le but d’apprendre pour moi il faut que le lecteur essaie ses propres variantes "et si je faisais comme sa plutôt" "mon objectif à moi c’est sa, il faudrai peut-être que j’ajoute sa pour que sa marche", bref, cela fait que l’on sort des clous du tuto, et quand bien même on n’en sortirai pas on va se planter quelque par.

La source

Oui, je suis entièrement d’accord avec ça. De toute manière, chacun se trompera à un moment ou un autre, surtout s’il expérimente (ce qui est recommandé).

Faire des erreurs quand on apprend, c’est normal, et comme chacun fait lui même; s’il y a certes des erreurs fréquente il y a finalement autant de façon de se planté qu’il n’y a de lecteur du tuto.

La source

Mais si un sujet externe est capable de lister ces erreurs et d’en proposer une correction, c’est bien que celles-ci sont connues, et pourraient être expliquées dans le cours (avec des chapitres annexes par exemple). Et pour le reste, donner des pistes pour la résolution d’erreurs par soi-même.

Mais mon point n’était même pas là, il s’agissait plutôt de parler des contenus qui induisent en erreur.

Mais si un sujet externe est capable de lister ces erreurs et d’en proposer une correction, c’est bien que celles-ci sont connues, et pourraient être expliquées dans le cours (avec des chapitres annexes par exemple). Et pour le reste, donner des pistes pour la résolution d’erreurs par soi-même.

Mais mon point n’était même pas là, il s’agissait plutôt de parler des contenus qui induisent en erreur.

entwanne

On ne peut pas mettre dans un tuto tout ça. Il y aura forcément des passages trop longs pour tel lecteurs, et des passages que tel autre lecteur n’aura pas compris, pour telle ou telle raison.

Le tuto parfait, il va contenir des QCM à intervalle régulier. Le lecteur fait les exercices à la fin d’un chapitre. Et selon ses réponses, on va le ré-aiguiller vers la relecture du chapitre passé, ou vers le chapitre suivant. Eventuellement, on va même l’aiguiller vers un chapitre super détaillé si on voit qu’il a besoin de beaucoup de précision, ou vers un chapitre sur le même sujet, mais moins détaillé, car le lecteur a visiblement le niveau suffisant.

Pour revenir au contenu du programme actuel, les range sont expliqués vers le milieu. Ok… mais les boucles for ou while sont également expliquées vers le milieu du tuto. Et ça, ça me paraît trop tard.

Je ne raisonne pas du tout comme un informaticien. Je ne cherche pas du tout à voir les entrailles de Python, et à partir de ça, faire un plan. Je ne raisonne que du point de vue du lecteur. Et je pense que si il faut lire 30 ou 40 pages avant de savoir faire une boucle, tu vas perdre 75% de tes lecteurs en route.

Par exemple, tu dis que le for Python n’a rien à voir avec le for du C. Techniquement, tu as certainement raison, ce n’est pas le débat. Mais pour le lecteur débutant (n’oublions pas que c’est lui la cible), une boucle for, c’est une boucle for, peu importe le langage.

+0 -0

Faire des erreurs fait partie de l’ apprentissage, elle n’ était pas du à la qualité du tuto mais à moi-même. C’est juste qu’il faut pas mettre une éternité à trouver la réponse. C’est pas simple la prog !

+0 -0

Je ne raisonne pas du tout comme un informaticien. Je ne cherche pas du tout à voir les entrailles de Python, et à partir de ça, faire un plan. Je ne raisonne que du point de vue du lecteur. Et je pense que si il faut lire 30 ou 40 pages avant de savoir faire une boucle, tu vas perdre 75% de tes lecteurs en route.

elegance

Mais pourquoi le débutant en question saurait ce qu’est une boucle, et aurait soudainement envie d’en écrire une ?

Je ne pense pas que les boucles fassent partie des choses les plus simples à appréhender, et qu’il vaut mieux un minimum de connaissances avant d’y venir.

Par exemple, tu dis que le for Python n’a rien à voir avec le for du C. Techniquement, tu as certainement raison, ce n’est pas le débat. Mais pour le lecteur débutant (n’oublions pas que c’est lui la cible), une boucle for, c’est une boucle for, peu importe le langage.

elegance

Oui, parce que je ne considère pas que le débutant en question aura pratiqué du C avant.

Et non, une boucle for ce n’est pas une boucle for quel que soit le langage. Ce n’est pas qu’une question technique, le for en Python n’a rien à voir avec celui du C, si ce n’est le nom.

En Python, on itère sur un objet, en C c’est juste du sucre autour d’un while.

Faire des erreurs fait partie de l’ apprentissage, elle n’ était pas du à la qualité du tuto mais à moi-même. C’est juste qu’il faut pas mettre une éternité à trouver la réponse. C’est pas simple la prog !

buffalo974

Je pensais que tu faisais références aux erreurs qui ont été relevées dans le cours de prolixe.

Mais effectivement, tout débutant (et pas que) fera des erreurs. Il est simplement préférable que le cours puisse apporter des pistes de réponses.

je salue au passage la force de prolixe (ici pour comprendre : https://openclassrooms.com/forum/sujet/python-tutoriel-pyton-60992)

buffalo974

Ah je me souvenais de ce sujet mais pas du HS qui s’en était suivi.

Tout ce travail pour des icônes aujourd’hui abandonnées (puisque OpenClassrooms ne les affiche plus)…

Marrant aussi de retrouver une trace du moment où je me suis tourné vers pySFML ^^

Je pense que tu peux faire ton cours par petits bouts, et adapter selon le feed back des élèves. C’est une belle initiative.

buffalo974

Ouais, c’est une idée. Je pense de toute façon que vu la quantité de choses à écrire, si ce projet voit le jour, il aura une très longue période de gestation en béta.

Édité par entwanne

Tiens, en lisant ce post de nohar je réalise que rien dans ce billet ne parle des tests, et de la nécessité de les aborder au cours de l’apprentissage.

En rejetant un œil à l’ébauche de plan, je me dis que la notion de tests peut être décrite juste après les fonctions, en introduisant le mot-clé assert et en montrant comment écrire quelques fonctions de tests. Plus loin, les modules permettent de parler d’écrire un module séparer pour les fonctions de tests. Et en dernier lieu, il conviendrait d’aborder de vraies bibliothèques/frameworks de tests, pour aller plus loin et vraiment mettre en place un environnement de test.

Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte