Python 3 pour l'apprenti sorcier.

Salut !

Ce sujet a pour but d'organiser la rédaction du premier cours de ce projet, à savoir « Python 3 pour l'apprenti sorcier », dont la rédaction collaborative est menée sur ce dépôt GitHub.

Suite à une remarque pleine de bon sens dans les issues, il est clair qu'il faut qu'on définisse un plan, grâce auquel il sera plus facile d'avancer en parallèle…

D'abord, l'objectif du cours est de transmettre une bonne base à propos de la programmation Python, à des débutants complets. Je pense qu'on peut sainement se dire que cette "bonne base" correspond plus ou moins à ce qu'on peut attendre d'un élève d'ISN en Terminale (mais en carrément plus solide, évidemment¹) :

• Manipuler des variables, reconnaître les types de données (sans oublier que ce sont tous des objets) ;
• Utiliser et écrire des fonctions (passage par référence, arguments optionnels, keyword arguments) ;
• Connaître les structures de contrôle du flot d'exécution :
  • if/else,
  • while(/else),
  • for(/else),
  • try/except/finally(/else),
  • with ... (as ...);
• Gérer les exceptions (sans forcément savoir définir des nouveaux types d'exception) ;
• Manipulations simples sur des fichiers (lire/écrire dans un fichier, a minima en mode texte) ;
• Manipuler les builtins (list, tuple, set, str,…) ;
• Utiliser quelques fonctions (et objets) de la bibliothèque standard, aller piocher des infos dans la doc ;

En somme, être capable d'écrire un programme Python structuré (compatible avec un projet d'ISN). La limite haute du cours c'est le mot-clé class, qui marquera le début du cours suivant sur la conception et la programmation orientées objet : à la fin de ce cours l'apprenant a juste besoin de savoir utiliser des objets et savoir plus ou moins que tout est un objet. Ça fait déjà un bel éventail, j'en conviens.

Mettons-nous d'accord sur le plan. Une fois un consensus atteint, on pourra créer les issues correspondantes sur GitHub.

Voilà un premier jet du plan :

1. Introduction

   • Généralités
   • Installation (à terminer)

2. Premier contact avec la console interactive (déjà écrit)

   • premières notions de programmation (expression, sémantique, syntaxe)
   • manipulation rapide de chaînes et de nombres

3. "Des noms et des objets" (déjà écrit)

   • Notion de variable
   • Notion de type: certains objets sont des données (str, int, float) et d'autres sont des actions (fonctions)

4. Branchements confitionnels (entamé)

   • Booléens
   • prédicats (not, or, and)
   • if/else
   • while

5. Collections

   • Listes
   • tuples,
   • dictionnaires
   • boucle for
   • opérateur in

6. Fonctions

   • Définition d'une fonction (def, return)
   • arguments optionnels

7. Gestion des exceptions

   • try/except/finally
   • raise (en se servant d'exceptions standard, style RuntimeError, ValueError…)

8. Manipulation de fichiers

   • open()
   • read()/write()
   • itération sur un fichier en mode texte
   • with open(...) as monfichier:

Tout cela devrait évidemment être entrecoupé de TD/TPs qui seront d'abord des exemples détaillés, puis qui deviendront progressivement de simples cahiers des charges au fur et à mesure que le cours avancera.

Évidemment, rien n'est figé dans le marbre.

Qu'en pensez-vous ? Voyez-vous des oublis ? Avez-vous des remarques ? Suggestions ?

Bon, je suppose que le plan convient…

Si personne ne se manifeste je créerai les issues ce soir.

Merci pour ces encouragements, ça fait du bien au motivateur !

Je viens de créer les issues sur GitHub pour les chapitres cités plus haut. Ça devrait suffire à nous occuper pour un moment.

Rien à redire…Super bien écrit

D'un côté, apprendre à manipuler les structures de base (listes, dictionnaires…) est essentiel et il est légitime d'inclure cela dans un tel cours. De l'autre, ça me semble aussi un bon moyen, dans un cours sur la programmation orientée objet, de fournir une compréhension pratique de ce qu'est un objet. J'ai vaguement esquissé une piste de plan¹ ici.

Ca ne pose pas de problèmes si les deux cours sont lus à la suite mais, dans le cas contraire, un cours sur l'OOP commençant par les classes me semble un peu abstrait.

Je lis régulièrement ton cours, à côté des autres que j'ai déjà commencé (celui de Swinnen et celui de OC), je trouve que le tien est plus accrocheur que les autres, il demande beaucoup moins de volonté pour poursuivre la lecture !

Je t'encourage beaucoup à poursuivre.

Après, je pense qu'en toute fin du cours, une courte introduction à la POO serait intéressante et pousserait le lecteur à chercher plus loin et à continuer d'améliorer ses connaissances.

Merci !

En fait, la POO fait l'objet d'un tutoriel à part dans le parcours que l'on a prévu.

La raison principale, c'est que pour faire certaines choses avec Python (comme la programmation système) il n'y a absolument pas besoin de POO, du coup, autant conserver la base dans ce tuto et renvoyer vers le tuto POO pour ceux qui désirent continuer dans cette voie à la fin de celui-ci.

J'ai lu ce que tu avais fait jusque-là, et je t'encourage à poursuivre ! Comme poliorcetics, j'ai trouvé ton cours plus accrocheur que ceux que j'avais déjà parcourus. Bravo et bonne continuation donc !

Salut,

Connaissant déjà le python (j'ai lu une grande partie du cours de Swinnen), j'ai apprécié grandement ton tutoriel, il est facile à lire et à suivre, et surtout va droit au but.

Une remarque qui m'est venu en parcourant le cours de Swinnen :

Lorsque tu proposes des TP (surtout ceux au départ), il serait bien d'indiquer si une fonction de la librairie standard de python fait le même job que ce qu'on doit recréer et s'il y en a une laquelle. Ça ferait à la fois prendre conscience à l'élève que ce qu'il écrit est probablement déjà mieux fait ailleurs si c'est une opération qui est souvent faite, mais aussi cela lui éviterait d'utiliser son propre code pour ses futurs projets, allégeant et clarifiant ainsi la lecture pour tous (et évitant potentiellement de nombreuses erreurs).
Par exemple en ISN, on demande un projet commun en fin d'année. Ce sera forcément un plus si les élèves utilisent le maximum d'outils à leur disposition et qu'en plus ils montrent qu'ils ont cherchés à maximiser leurs performances et leurs connaissances.

Je suis d'accord. Apprendre à utiliser Python c'est justement apprendre à ne pas réinventer la roue.

Petit up pour savoir si le projet avançait et si je pouvais aider (dans autre chose que la rédaction je n'ai pas le niveau) car il m’intéresse FORTEMENT

Il avance très peu, faute de disponibilité. L'écriture se déroule ici. Si tu souhaites participer, n'hésite surtout pas à te manifester dans une issue, histoire qu'on sache ce que tu prévois de faire.

Je suis assez peu dispo ces temps-ci, mais je n'abandonne pas !

J'aiderai bien sur Github mais je ne sait pas m'en servir :s

Est-ce juste GitHub, la plateforme, qui te pose problème ou également git, le gestionnaire de versions ?

Dans tous les cas, tu peux toujours envoyer ton texte en MP à un rédacteur, lequel se chargera de faire la liaison avec GitHub. L'organisation se déroule ici.

Git en général . Je suis pas dev j'ai essayé vaguement et globalement j'ai RIEN CAPTE .

Juste je me proposais pour des tâches plus annexes comme des relectures ou autres

C'est vrai que Git demande un coût d'apprentissage. J'en suis conscient. D'un autre côté il est aussi possible de modifier directement les fichiers sur GitHub.

Du reste, github (et le principe de pull-requests etc.) demande aussi un petit overhead d'apprentissage. Mais je pense que cette techno est tellement porteuse (et meilleure que la "concurrence") que cet apprentissage est un excellent investissement à court, moyen et long terme.

Juste je me proposais pour des tâches plus annexes comme des relectures ou autres

Dans ce cas-là, tu peux, je pense, te contenter de GitHub. Sans écrire du contenu à proprement dit, tu peux participer de plusieurs manières :

• Intervenir dans les issues (y compris en créer) : ce sont des fils de discussion à travers desquels on s'organise.
• Commenter les PR : c'est là que les auteurs proposent des modifications au niveau du texte. Un exemple de commentaire là.
• Ajouter des line notes : cela permet de commenter un point précis d'une PR. Tu as des exemples ici.

Mais, en effet, apprendre git (et GitHub) est un très bon investissement. Tu peux pour ce faire lire ce bouquin, gratuit (la version anglaise est très bien, donc j'imagine que celle française n'est pas trop mauvaise).