Rédaction d'une collection de tutoriels Python

Qui ? Quoi ? Comment ?

L'auteur de ce sujet a trouvé une solution à son problème.
Staff
Auteur du sujet

Salut les pelures !

Je crée ce sujet suite à cette idée qui semble avoir plu.

Pour résumer, on est tombés d'accord sur le fait que ce serait génial de créer, pour une techno donnée (ici Python), un ensemble de moyen-tutos (1 partie = quelques chapitres seulement) ciblés que l'on relierait ensuite entre eux par un moyen ou un autre, plutôt que de confier l'écriture d'un cours monolithique à un seul auteur, pour tout un tas de raisons qui sont citées dans la discussion susmentionnée. En tout cas, vous l'aurez compris : le but du jeu est de confier à la communauté l'écriture d'un méga-tuto Python communautaire, qui fera la différence sur le web francophone par sa qualité, sa complétude, son ouverture et son adaptabilité aux objectifs de n'importe quel débutant. C'est ambitieux, oui. C'est même très ambitieux, mais si on y met tous un peu de temps et de passion, c'est largement faisable, et imaginez un instant le résultat final ! ;)

Voilà ce que ça pourrait donner :

Carte prévisionnelle

Version cliquable

Les tutoriels en rouge/orange ont un statut CRITIQUE (besoin d'être rédigés en priorité), et ceux en vert sont déjà terminés.

Ce sujet a pour but que l'on s'organise pour savoir :

  • QUI veut rédiger des tutos Python ou tout simplement aider d'une façon ou d'une autre ?
  • Sur QUEL(S) sujet(s) ? (Programmation scientifique ? Système ? Optimisation ? Jeux ? Web ? Quelles libs ?)
  • COMMENT pourrions-nous les lier entre eux pour guider l'apprenti Pythoniste ?

Pour ce dernier point, j'ai pensé que rédiger les cours sur GitHub de façon à ce qu'on puisse se PR-iser les uns chez les autres serait déjà un bon point de départ.

Voici les tutoriels déjà entamés :

Thème Titre Dépôt Contributeurs
Python (base) Python 3 pour l'apprenti sorcier cours-python3 nohar, Ge0, entwanne
Système La programmation système en Python cours-python-systeme nohar
Notions avancées Cours Python avancé cours_python_avance entwanne

Pour être ajouté à ce tableau :

  • créez simplement un dépôt GitHub avec les sources de votre tutoriel (si besoin, vous pouvez vous inspirer des dépôts existants pour avoir une version de travail en Markdown, et un makefile pour tout compiler en html/epub/pdf avec Pandoc),
  • ou bien faites une pull-request sur un tuto existant : toute forme d'aide sera bienvenue et très appréciée !

Le tutoriel de base a grand besoin de contributeurs : je traîne des pieds sur sa rédaction car je manque de patience pour enseigner la base de la base, et que je ne dispose pas d'un temps illimité à consacrer à la rédaction.

Qu'en pensez-vous ? Êtes-vous intéressés ? Par quoi ?

Voici une liste d'idées en vrac :

Asyncrone

  • asyncio

Base de données

  • pymongo

Interface graphique

  • Kivy
  • turtle

Multimédia (jeu, image, son, vidéos, et)

  • Pillow
  • pygame

Optimisation

  • Cython et ctypes
  • profiling CPU et mémoire

Qualité / Documentation

  • flake 8 / pylint (gustavi)
  • pydoc
  • Sphinx

Réseau

  • socket, socketserver
  • request
  • pycurl

Scientifique

  • Matplotlib
  • numpy
  • Pandas
  • Scikit learn
  • SymPy

Template

  • Jinja2 (gustavi)
  • moya (gustavi)

Web

  • bottle
  • CherryPy (gustavi)
  • Django - API avec DRF (gustavi)
  • Django - Les formulaires avancées (gustavi)
  • Flask
  • Tornado (artragis, gustavi)
  • web2py
  • webbrowser

Personnes intéressées et domaines (à compléter) :

  • Dan737 : python débutant
  • entwanne : python avancé, réseau
  • Gabbro : calcul scentifique
  • gustavi : base, framework web, optimisation
  • Karnaj : scientifique
  • Kje : calcul scentifique
  • nohar : base, système, réseau, optimisation

Édité par nohar

I was a llama before it was cool

+25 -0

Hello,

Tu connais déjà mon avis et ma réponse là-dessus.

J'en pense que c'est une bonne idée.

Je suis intéressé par :

  • rédiger certaines parties dont certains ne veulent pas ;
  • faire de la relecture à des fins orthographiques / pédagogiques / véracité de code.

Et je comprends l'utilisation de la plate-forme github pour ce projet d'envergure. Je dénote juste une chose : ça peut donner des idées pour avoir de meilleurs fonctionnalités de rédaction d'articles/tutoriels peut-être ? (Le coup des Pull Requests et de la review, etc.)

+0 -0
Staff
Auteur du sujet

rédiger certaines parties dont certains ne veulent pas ;

Dans quels domaines ? J'ai désespérément besoin de gens motivés pour rédiger sur le tuto de base. Si tu veux je peux t'y coller comme contributeur principal pour t'épargner les reviews.

I was a llama before it was cool

+0 -0

Bah par exemple, lorsque j'ai vu un TODO sur l'installation Windows, je m'y suis collé.

Pour ce qui est du langage lui-même, s'il faut énoncer des concepts pas trop compliqués (à expliquer tout du moins) je suis preneur ! :)

+0 -0

Noooooooooooon ! >_<

En fait, pour commencer, tu n'as qu'à me proposer de rédiger telle ou telle partie afin de me mettre en confiance ?

Je parle pour moi car je ne sais pas comment fonctionnent les autres potentiels contributeurs, ni ce qu'ils attentent.

+0 -0
Staff

Si certains d'entre vous ont entendu parler de la zep12 qui supporte la création de"tuto moyens" n' attendez pas qu'elle soit développée pour rédiger un tuto qui est pour l' instant marqué comme"BIG" mais qui n' a qu'une partie et quelques chapitres. Vous pourrez "aplatir" votre tuto a posteriori quand la zep12 arrivera grâce à notre fonctionnalité de déplacement amélioré.

+2 -0
Staff

Cette réponse a aidé l'auteur du sujet

Perso je vais essayé de lancer un tuto sur le calcul scientifique. Je pense au début présenter numpy est les 2-3 notions a connaitre (broadcasting, ufunc, indexing). Mais pas question de faire un redit de la d'oc concernant toutes les fonctions. Ensuite peut etre présenter quelques lib scientifique et ensuite laisser les membres compléter avec leur lib préféré.

Apres je pense que ca pourrait etre sympa de parler optimisation : profiling CPU et mémoire, codes python plus efficaces, et a la suite de ça tu peux le relier aux section sur le calcul scientifique et celui sur cython.

+1 -0
Staff
Auteur du sujet

Apres je pense que ca pourrait etre sympa de parler optimisation : profiling CPU et mémoire, codes python plus efficaces, et a la suite de ça tu peux le relier aux section sur le calcul scientifique et celui sur cython.

Clairement je ne comptais pas parler d'optimisation sans parler de profiling. Ça pourrait du coup faire un tutoriel indépendant. En fait c'est vrai, on s'en fout si y'a que 2 ou 3 chapitres ! :D

I was a llama before it was cool

+1 -0
Staff

En fait c'est surtout que je ne mettrais pas cython directement dedans. Car cython sert aussi aux bindings. Donc plutot un profiling + optimisation en python pur et ensuite des liens vers tous les tutos qui peuvent faire gagner du temps (cython, numpy, etc.)

+1 -0
Staff
Auteur du sujet

Ok. Alors dès que j'ai un peu de temps je sors mon copain graphviz pour qu'on ébauche une carte des tutos. ;)

Édité par nohar

I was a llama before it was cool

+1 -0
Staff

Cette réponse a aidé l'auteur du sujet

En vrac, pendant que j'y pense, des thématiques qui pourraient être sympa à avoir (je donne des idées) :

  • Interface graphique moderne avec Kivy (moyen-tuto pour l'utilisation de base + un autre moyen tuto pour les trucs avancés (shaders & co) mais moins important)
  • Manipulation de bases des images avec Pillow (moyen tuto)
  • Faire des requêtes avec requests (un mini-tuto ou un moyen avec 2-3 chapitres max) – typiquement citée en intro de celui "La programmation réseau" en mode "si vous voulez un module plus haut niveau pour faire des requetes à un serveur http, utilisez plutôt request" (et inversement dans celui sur request)
  • Django (ou mettre à jour celui présent)
  • Autres frameworks web : Flask (un moyen sur les bases, un moyen sur les notions avancés), bottle (un seul moyen devrait suffire), Web2py, etc.
  • Moteur de template Jinja2 (il est utilisé par flask par defaut, peut etre utilisé optionnellement par Django, bottle, autant en faire un tuto indépendant)
  • Dans le monde scientifique, qui peut avoir de l'interet : Scikit learn pour le maching learning, Pandas pour les stats, Matplotlib (et les dérivés) pour des beaux graph, SymPy pour le calcul symbolique
  • On pourrait faire une section outils aussi : pip, virtualenv, pdb, ipython, ipython-notebook/project Jupyter, annaconda pour les windowsiens, Spyder pour les matlabeux, etc.
  • OpenCv si il y a des grand motivés, ou peut être une collection de petits tutos sur des themes précis.
  • pymongo pour l'interfaçage avec MongoDB puisque mon petit doigt m'a dit qu'un tuto portant sur MongoDB était prévu, ça ferait un bon entre les tutos python et ce tuto a part.

Voila ce sont juste des idées en vrac pour ceux qui en cherchent. Il faudrait aussi trouver un moyen d'explorer la lib standard. Beaucoup de tutos vont la brosser indirectement mais certaines parties ne pourront être couvertes où seront difficile d’accès. Une idée serait peut être de préparer une série d'article/mini-tuto, chacun sur un module de la lib standard. Ça permetrait à chaque tuto de les référencer ("Nous allons utiliser les namedtuple dans ce chapitre, assurez vous d'avoir lu cet article a propos du module collections de la lib standard"). Si on arrive à se préparer un pool, on peut imaginer faire des publications régulières ("Module python du mois/de la semaine")

Voila pour le moment.


edit: Je pense vraiment qu'il ne faut pas hésiter a couper une thématique en 2. Faire un tuto sur les utilisations basiques et un autre sur les utilisations avancés. Ce serait plus facile a écrire (celui sur les bases ne necessite pas les meme compétences que celui avancé, etc. ) et ce sera plus agréable pour le lecteur. Par exemple quand je parle de Kivy, la majorité des utilisateurs vont utiliser les composants de bases fournit, pas besoin de parler de la pipeline OpenGl au début. Pour moi ça devrait être découpé en deux.

Édité par Kje

+5 -0
Staff

Cette réponse a aidé l'auteur du sujet

Je peux aider pour le calcul scientifique principalement.

Pour Numpy, parler de tout ce qui est slice (a[:,0]), qui est très efficace, assez intuitif pour les gens qui viennent de matlab et compagnie, mais pas forcement les autres. Toute les trucs du genre numpy.where, plus utile pour les gens qui viennent du fortran.

Et un trucs pour aider à explorer la doc. Les enseignants-chercheur qui passent à python critique gentiment la doc, qu'ils considèrent être « pour les développeurs de numpy/matplotlib, pas les utilisateurs ».

Pour sympy, mis-à-part deux trois piège (comme a + 1/2 != a + Integer(1)/Interger(2) ), la doc est pas mal. Une bonne intro serait suffisent à mon avis.

Pour les optimisation, il existe des choses moins lourde que Cython qui augmente pas mal les performances, comme paraket ou pythran. Je n'ai jamais eu à utiliser en profondeur, mais ça permettrait peut-être une approche plus progressive. Ce dernier à l'avantage d'être très facile d'utilisation (quelques lignes, et c'est bon !).

Je vais jeter un œil au tuto pour débutant. Mais pour le coup, je ne suis pas sure d'être le mieux placé.

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

+1 -0
Staff
Auteur du sujet

Pour les optimisation, il existe des choses moins lourde que Cython qui augmente pas mal les performances, comme paraket ou pythran.

Je connais pas ces technos, mais au survol je me rends compte qu'elles ne concernent que Python 2.7, et que Pythran ressemble quand même beaucoup à ce que fait Cython dans l'idée… Après si quelqu'un se sent de rédiger dessus, on ne va certainement pas dire non ! L'avantage de créer un arbre de tutos, c'est justement de pouvoir les inclure côte à côte dans la même région.

Édité par nohar

I was a llama before it was cool

+0 -0

Cette réponse a aidé l'auteur du sujet

Salut,

je serais intéressé pour rédiger quelques articles/chapitres, mais plutôt sur des sujets plus avancés de Python que sur les bases. Le problème est que j'estime difficilement le temps que je pourrais y accorder.

Pour les sujets, j'ai déjà pensé aux habituelles structures plus avancées du langage (itérateurs, générateurs, context managers, décorateurs, métaclasses), mais aussi l'interfaçage C/Python, par exemple. Côté bibliothèques, je pourrais contribuer sur les sujets que je connais, comme Sphinx, Pillow, Django, pysfml (mais là, la compatibilité du portage Python étant cassée à chaque version, c'est pas gagné), ainsi que du réseau avec requests ou pycurl.

De façon plus régulière, je peux aussi sans problème aider aux relectures et corrections.

Édité par entwanne

Staff
Auteur du sujet

Ça me fait penser que le tuto sur les bases de python pourrait facilement se scinder en deux ou trois moyen-tutos.

  • La base de la base, utiliser des obhets de la lib standard.

  • POO et Conception

  • Notions avancées et black magic

Typiquement ça raccourcirait l'apprentissage de quelqu'un qui veut aller droit à l'essentiel par rapport à son objectif à lui. Par exemple : Base -> système ou base -> calcul scientifique. En se promettant de revenir aux autres notions génériques plus tard.

I was a llama before it was cool

+0 -0
Staff
Auteur du sujet

Bon, je me suis amusé (je rajoute l'image sur le premier post) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#!/usr/bin/env python3
import graphviz as gvz


GRAPH_STYLE = {
    'fontsize': '16',
    'fontcolor': 'white',
    'bgcolor': '#094662',
    'rankdir': 'LR',
    'rankType': 'same',
    'splines': 'true',
    #'layout': 'circo',
    'overlap': 'false',
    'label': 'Carte des tutos Python',
    'root': 'Python',
}

NODE_STYLE = {
    'fontname': 'sans-serif',
    'fontcolor': 'white',
    'color': '#F8AD32',
    'style': 'filled',
    'fillcolor': '#006699',
}

EDGE_STYLE = {
    'color': '#F8AD32',
    'arrowhead': 'open',
}


FINISHED = {'fillcolor': 'green'}
CRITICAL = {'fillcolor': 'red'}

dot = gvz.Digraph(filename='tuto_map', format='svg', name='tuto_map')
dot.graph_attr.update(GRAPH_STYLE)
dot.node_attr.update(NODE_STYLE)
dot.edge_attr.update(EDGE_STYLE)


def add_external_dependency(name):
    dot.node(name, style='dashed')
    external.add(name)


def add_tuto(name, depends=tuple(), external=tuple(), url=None, status=None):
    attrs = status or {}
    dot.node(name, href=url, **attrs)
    for dep in external:
        add_external_dependency(dep)
        dot.edge(dep, name)

    for dep in depends:
        add_tuto(dep)
        dot.edge(dep, name)


add_tuto('Python',
         url='https://github.com/ArnaudCalmettes/cours-python3',
         status=CRITICAL)

add_tuto('POO', depends=['Python'])
add_tuto('Système', depends=['Python'], external=['Linux'],
         url='https://github.com/ArnaudCalmettes/cours-python-systeme')

add_tuto('Calcul scientifique', depends=['Python', 'Optimisation'])
add_tuto('Notions avancées', depends=['POO'])
add_tuto('Django', depends=['POO'], external=['HTML/CSS'],
         url=('https://zestedesavoir.com/tutoriels/232/'
              'developpez-votre-site-web-avec-le-framework-django/'), 
         status=FINISHED)

add_tuto('Réseaux', depends=['POO'])
add_tuto('Optimisation', depends=['POO', 'Système'])
add_tuto('Cython', depends=['Optimisation'], external=['C et/ou C++'])
add_tuto('Jeux', depends=['POO'])

dot.render(cleanup=True)

N'hésitez pas à corriger/compléter. ;)

Édité par nohar

I was a llama before it was cool

+0 -0

Sympa comme initiative, je compte bien suivre l'évolution des tutos. Cette approche de dépendances entre tutos devrait être étendue à tout le site (je ne sais pas s'il y a quelque chose de prévu lors de la rédaction pour indiquer les dépendances).

@nohar -> pas des listes à la place des tuples ?

51
def add_tuto(name, depends=list(), external=list(), url=None, status=None):
Staff
Auteur du sujet

Si tu mets des objets muables en argument par défaut, tu t'exposes à des surprises. ;)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
>>> def myfunc(arg=[]):
...     arg.append('spam')
...     print(arg)
... 
>>> myfunc()
['spam']
>>> myfunc()
['spam', 'spam']
>>> myfunc()
['spam', 'spam', 'spam']
>>> myfunc()
['spam', 'spam', 'spam', 'spam']

Du coup je préfère placer des tuples vides : des itérables immuables, quoi.

Édité par nohar

I was a llama before it was cool

+3 -0
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