Rédaction d'une collection de tutoriels Python

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 :

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 :

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 !

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

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.)

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.

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 !

OK, je vais de ce pas commiter des TODO sur tout le tuto alors.

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.

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é.

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 !

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.)

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

, SymPy pour le calcul symbolique

tu as aussi sagemath qui est assez bon pour ça, il intègre tout et en plus il a une interface client/serveur qui est portée sur le cloud.

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.

En vachement moins lourd et plus moderne, il y a numba. De toute façon, tant que ca concerne python, ca pourra etre lié au reste.

Ç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.

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.

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):

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.