Claude SIMON a écrit 539 commentaires

En fait, les chaînes de caractères qui transitent par ces fonctions sont uniquement récupérées de formulaires HTML et affichées dans des pages HTML, tous encodés en utf8 ; elles ne sont jamais lues à partir de la console, ou écrites dans la console. C'est peut-être pour cela que je n'ai jamais rencontré de problèmes…

Pour nous émanciper des géants du numérique : Zelbinium !

pourquoi passer de str/chr à bytes ? ça j'ai pas suivi…

Certaines fonctions qui prenaient un string en version 2 n'acceptent plus qu'un objet bytes en version 3, comme la méthode send de l'objet socket (v2, v3).

pourquoi ajouter decode("utf-8") alors qu'un use utf-8 suffirait en en-tête ? (bientôt obsolète j'espère)

"utf-8" est inutile, étant la valeur par défaut du paramètre correspondant, mais le decode() est nécessaire pour convertir l'objet bytes retourné par socket.recv(…) en string.

J'ai voulu essayer use …, mais je n'ai pas trouvé de documentation à ce sujet…

Pour nous émanciper des géants du numérique : Zelbinium !

Je viens d'essayer avec Python 2.7.15+ avec les caractères ⯈⯈⯈ éàôö…, et ça fonctionne sans problème…

Pour nous émanciper des géants du numérique : Zelbinium !

Bonne idée, mais c'est un peu trop petit…

Je tente avec du Markdown :

 def writeByte(socket, byte):
-       socket.send(chr(byte))
+       socket.send(bytes([byte]))

 def writeSize(socket, size):
-       result = chr(size & 0x7f)
+       result = bytes([size & 0x7f])
        size >>= 7

        while size != 0:
-               result = chr((size & 0x7f) | 0x80) + result
+               result = bytes([(size & 0x7f) | 0x80]) + result
                size >>= 7

        socket.send(result)

 def writeString(socket, string):
-       writeSize(socket, len(string))
-       socket.send(string)
+       bString = bytes(string, "utf-8")
+       writeSize(socket, len(bString))
+       socket.send(bString)

 def writeStringNUL(socket, string):
-       socket.send(string + "\0")
+       socket.send(bytes(string + "\0", "utf-8"))

 def getByte(socket):
        return ord(socket.recv(1))
@@ -65,6 +66,8 @@
        size = getSize(socket)

        if size:
-               return socket.recv(size)
+               return socket.recv(size).decode("utf-8")
        else:
                return ""

Pour nous émanciper des géants du numérique : Zelbinium !

[…] à part la différenciation str/bytes qui ajoute de la complexité apparente à Python3. Je dis bien apparente car elle force au final à raisonner de manière plus précise sur nos données […]

Il y a quelque temps, j'ai développé des fonctions pour faire transiter des chaînes de caractères via des sockets. Bien que je n'avais quasiment jamais fait de Python, j'ai trouvé la version pour Python 2 assez facile à écrire. Par contre, pour la version Python 3, ça a quand même été un petit peu plus compliqué.

Voilà les deux versions ; on ne sait jamais, ça servira peut-être à quelqu'un…

(Oui, je sais, je n'aurais pas du utiliser le camelCase, mais je débutais en Python, et n'avais pas connaissance des règles en la matière…)

La version pour Python 2 :

def writeByte(socket, byte):
    socket.send(chr(byte))

def writeSize(socket, size):
    result = chr(size & 0x7f)
    size >>= 7

    while size != 0:
        result = chr((size & 0x7f) | 0x80) + result
        size >>= 7

    socket.send(result)

def writeString(socket, string):
    writeSize(socket, len(string))
    socket.send(string)

def writeStringNUL(socket, string):
    socket.send(string + "\0")

def getByte(socket):
    return ord(socket.recv(1))

def getSize(socket):
    byte = getByte(socket)
    size = byte & 0x7f

    while byte & 0x80:
        byte = getByte(socket)
        size = (size << 7) + (byte & 0x7f)

    return size

def getString(socket):
    size = getSize(socket)

    if size:
        return socket.recv(size)
    else:
        return ""

et la version pour Python 3 :

def writeByte(socket, byte):
    socket.send(bytes([byte]))

def writeSize(socket, size):
    result = bytes([size & 0x7f])
    size >>= 7

    while size != 0:
        result = bytes([(size & 0x7f) | 0x80]) + result
        size >>= 7

    socket.send(result)

def writeString(socket, string):
    bString = bytes(string, "utf-8")
    writeSize(socket, len(bString))
    socket.send(bString)

def writeStringNUL(socket, string):
    socket.send(bytes(string + "\0", "utf-8"))

def getByte(socket):
    return ord(socket.recv(1))

def getSize(socket):
    byte = getByte(socket)
    size = byte & 0x7f

    while byte & 0x80:
        byte = getByte(socket)
        size = (size << 7) + (byte & 0x7f)

    return size

def getString(socket):
    size = getSize(socket)

    if size:
        return socket.recv(size).decode("utf-8")
    else:
        return ""

(Code source extrait respectivement de https://github.com/epeios-q37/atlas-python/blob/be77cf9d5c8921877fecc1ed1bfa3819fc7e7546/atlastk/XDHqDEMO2.py et https://github.com/epeios-q37/atlas-python/blob/be77cf9d5c8921877fecc1ed1bfa3819fc7e7546/atlastk/XDHqDEMO3.py.)

Pour nous émanciper des géants du numérique : Zelbinium !

… que Python est le langage retenu par l'Éducation nationale pour les cours de sciences numériques et technologie, cours qui est obligatoire pour tous les élèves des classes de seconde des lycées généraux et technologiques.

Pour nous émanciper des géants du numérique : Zelbinium !

Bonjour !

Alors, avant que je n'oublie, quelques liens qui donnent sur un 404 :

• dans le lien ci-dessus, section Librairies (qui, soit dit en passant, devrait être intitulée Bibliothèques), le lien sur entree ;
• dans le README.md du dépôt GiHub, les 4 derniers liens.

---

À mon tour, je me permets de présenter une approche différente, mais qui me semble complémentaire, à savoir une bibliothèque qui s'inspire de la tortue du Logo. Ça permet aux élèves d'écrire quelque-chose du genre :

tortoise.down()

for i in range(500):
    tortoise.setColorHSL(360 * i / 500, 100, 50)
    tortoise.forward(i/2.5)
    tortoise.left(91)

qui permet d'obtenir ça :

En combinaison avec l'outil présenté dans cette dépêche, on peut créer un exercice qui consiste à leur faire écrire, par exemple, quelque chose de ce genre :

baisse()

for y in range(0, 24):
    fixeCouleurTSL(T, 100, 50)
    T += 15
    for x in range(0, 12):
        avance(30)
        tourneDroite(30)
    tourneDroite(15)

J'en parle dans ce journal.

Pour nous émanciper des géants du numérique : Zelbinium !

Tu as dû mal lire la remarque de magnolia, ça n'est pas ce qu'il reprochait : il parlait bien du risque d'engager les profs dans cette voie.

De quoi parles-tu exactement ? Le commentaire auquel tu réponds est ma réponse à ta propre remarque …proposer ça comme outil à faire connaître à tous les lycéens…, pour signaler que ce n'est absolument pas le cas.

Et moi en plus en tant qu'apprenant, j'aime bien aller voir ce qu'il y a derrière. Ça sera problématique à ce moment-là également.

Et qu'est-ce qui serait moins problématique pour toi ? Un outil propriétaire développé par une multinationale qui en profiterait pour soutirer un maximum de données personnelles des élèves et des enseignants afin de les abreuver de publicités ?

Pour nous émanciper des géants du numérique : Zelbinium !

C'est tout le contraire. L'outil présenté dans cette dépêche est destiné à être utilisé par ceux qui élaborent les exercices, pas par les élèves auxquels sont destinés ces exercices.

Tout est fait pour rendre cet outil transparent pour les élèves. Dans le code que tape l'élève dans le cadre des exercices, à aucun moment il ne manipule l'API de la bibliothèque edutk, ni celle de la bibliothèque atlastk.

Pour nous émanciper des géants du numérique : Zelbinium !

Concernant l'idée d'une bibliothèque graphique :

Le post suggère de diriger les futurs profs de NSI/Python vers une bibliothèque maintenue par une personne qui n'est même pas installée par défaut sur les distributions Python classiques comme Anaconda. Cela me semble être une erreur grave. Je m'y connais plutôt en info (ce qui me permet d'être écouté oar les administrateurs du lycée) et c'est déjà compliqué pour demander aux administrateurs d'installer le moindre truc.

Les bibliothèques sont disponibles sur PyPi ; si Anaconda a un système équivalent de gestion de paquets, je veux bien créer ceux dédiés à ces bibliothèques, si cela peut en simplifier l'usage…

Ne parlons même pas de séparation entre le coeur du code et l'interface graphique d'un programme que ce genre d'enseignement va ignorer totalement.

Les manipulations concernant l'interface graphique étant réduites au minimum, seul celui qui élaborera les exercices sera amené à gérer la séparation interface/traitement…

Pour nous émanciper des géants du numérique : Zelbinium !

L'outil présenté fait une jolie présentation, pour certains élèves en collège/lycée ça peut être intéressant pour juste les intéresser à la chose (les élèves en prépa sont généralement un peu plus motivés et costauds que la moyenne). L'aspect accessible via Internet est un plus (quand c'est prêt c'est directement utilisable), et un moins (il faut quelqu'un qui sache le mettre en place et bénéficier d'un hébergement).

C'est pour que ce soit directement utilisable que je met à disposition un serveur gratuit et public, sachant que, comme on est sur du logiciel libre, on reste tout à fait libre (sans jeu de mot) de mettre en place son propre serveur…

Pour nous émanciper des géants du numérique : Zelbinium !

Pour ce qui est du post est des interfaces graphiques, je suis sceptique. Je suis prof dans une des meilleures prépa de France. Et je dois batailler en début d'année pour que les élèves comprennent qu'il y a une différence entre un print(a) et un return a. Écrire une interface graphique propre est un boulot de spécialiste et nécessite beaucoup de connaissances très spécifiques à la bibliothèque utilisée. Certes, c'est ici une bibliothèque très simple, qui permet de faire des input et des print plus jolis. Mais bon, je crois qu'il est plus important de savoir ce qu'est un tableau ou une table de hachage.

Et bien justement, le but de l'outil présenté ici est de pouvoir créer des exercices qui permettent aux élèves de profiter de tous les avantages d'une interface graphique, sans pour autant qu'ils aient à la manipuler directement, et ce afin qu'ils puissent se concentrer sur l'objet de l'exercice (tableau, table de hachage…).

Pour nous émanciper des géants du numérique : Zelbinium !

Excellente initiative !

Merci !

Je me permets une remarque superficielle sur la forme :
j'essaye personnellement de présenter de bonnes habitudes de rédaction de code python à mes élèves.
Par conséquent, je préférerais leur fournir des fonctions utilitaires dont les identifiants respectent les conventions de nommage en python et non en camelCase.

J'étais passé à coté de la PEP dédiée.

Ceci dit, pour autant que je sache, dans le cadre des cours de SNT/NSI, on ne cherche pas à initier les élèves à Python en particulier, mais à la programmation en général. Du coup, respecter les conventions de nommage Python n'est pas aussi important que ça, car si un élève décide, plus tard, d'utiliser un autre langage, il est probable qu'il aura affaire à d'autres conventions de nommage.

Maintenant, cet outil est totalement agnostique concernant les conventions de nommage ; on peut donc mettre en œuvre, dans les exercices, celle de son choix.

Je vais étudier de plus près ces outils que vous partagez généreusement.

N'hésitez pas à m'en faire part si vous rencontrez des problèmes, ou si vous avez des remarques/suggestions/questions…

Pour nous émanciper des géants du numérique : Zelbinium !

On peut aussi rester appuyé sur le bouton droit durant le déplacement, et le relâcher seulement une fois positionné. Ça économise un clic…

Pour nous émanciper des géants du numérique : Zelbinium !

Concrètement, comme je n'utilise pas la STL, je ne m'attarde pas sur les nouveautés qui s'y rapportent. Donc, concernant ces nouveautés, aussitôt lues, aussitôt oubliées.

Pour nous émanciper des géants du numérique : Zelbinium !

Des experts C++ qui se qualifie 4.5 / 5 en C++ et qui sont perdus dés avec 3 minutes quand tu leur parle de VTable.

Ça fait presque vingt ans que je programme quasi-exclusivement en C++, et ça ne me viendrait absolument pas à l'idée de me qualifier d'expert C++. D'une part, parce que je ne me considère pas comme tel, et, d'autre part, parce que je ne vois pas l'intérêt pour moi d'être un expert en C++, pour l'usage que j'en ai.

Le C++ est un outil que j'utilise de la manière qui me convient le mieux, qui n'est pas, j'en conviens, la plus répandue. Je me tiens au courant des fonctionnalités ajoutées au fur et à mesure des nouvelles versions et j'en adopte une de temps en temps (la dernière, ce sont les variadic templates, dont j'use et abuse), parce qu'elle me facilite mon travail de développeur. Ce qui fait que je dois n'en utiliser, au final, qu'une faible partie. Mais à quoi cela me servirait-il d'en connaître plus si je n'en ai pas l'usage ? À impressionner d'éventuels recruteurs ? Si mon compte Github ne leur suffit pas pour savoir si mes compétences en matière de programmation répondent ou non à leurs besoins, c'est leurs propres compétences qui laissent à désirer…

Pour reprendre une analogie fort populaire dans notre milieu : je possède ma voiture depuis plus de dix ans, et je bataille plusieurs minutes deux fois par an pour mettre mon auto-radio (intégré) à l'heure (c'était d'actualité il y a peu), alors que la procédure prend moins de 10 secondes si on la connaît. Du coup, malgré les dix ans et quelques que je l'ai en ma possession, difficile de me qualifier d'expert du modèle que je possède. Et ça ne me pose aucun problème, vu ce que je connais d'elle me suffit pour m'amener d'un point A à un point B dans des conditions que j'estime satisfaisantes.

Commentaire que j'ai écris il y quelques années sur comment ne pas être considéré comme un spécialiste C++ malgré une pratique quasi-quotidienne de plus de 12 ans : https://linuxfr.org/users/fredx/journaux/ce-qu-on-demande-a-un-developpeur-aujourd-hui#comment-1471811.

Pour nous émanciper des géants du numérique : Zelbinium !

Sous KDE, du moins avec Kubuntu, il y a Muon Package Manager. C'est assez proche de Synaptic, et je l'utilise systématiquement à la place de Discover. Le seul cas où j'utilise encore Discover, c'est pour les mises à jour, quand il s'ouvre lorsque l'on clique sur la notification.
Au début, je fermais la notification, et je faisais les mises à jour avec Muon. Mais Discover fait exactement les mêmes mises à jour, y compris les paquets qui n'apparaissent pas dans Discover et que j'ai donc installé via Muon, y compris également les paquets installés à partir d'un PPA, avec Muon.

Pour nous émanciper des géants du numérique : Zelbinium !

Petite erreur à la fin du premier paragraphe :

[…] et vous serez aider aidés.

Pour nous émanciper des géants du numérique : Zelbinium !

Le bouton Ranger les masses est cliquable une fois la balance à l'équilibre.

Pour nous émanciper des géants du numérique : Zelbinium !

J'ai eu, à l'occasion d'un projet, à programmer en différents langages (Java, Node.js, Perl, PHP, Python et Ruby), dont aucun ne m'était familier, la même bibliothèque faisant appel à des fonctionnalités assez poussées (réseau bas niveau, multi-tâche, gestion d'accès concurrents…), et c'est avec Python que je me suis le plus… amusé. En outre, pour l'implémentation de certains algorithmes, j'ai souvent écrit du code au feeling, trop paresseux que j'étais pour consulter la documentation, et c'est en encore avec Python que le code a le plus souvent fonctionné du premier coup, ou seulement après quelques modifications mineures. Ceci dit, les différences entre les versions 2 et 3, surtout concernant les fonctions réseau bas niveau, sont assez irritantes, mais il est assez facile d'écrire une surcouche qui permette de faire du réseau sans avoir à se préoccuper de la version utilisée de Python (version 2, version 3, surcouche).

Il y a quand même une singularité, que je qualifierais de maladresse, qui a du mal à passer. Par exemple, {1,2} est un set contenant deux nombres (notez les {} comme délimiteurs) et (3,4) un tuple contenant deux nombres (notez les () comme délimiteurs). Jusqu'à là, tout va bien. Par contre, bien que {5} est bien un set contenant un nombre, (6) n'est pas un tuple contenant un nombre, mais le nombre lui-même. Pour avoir un tuple contenant un seul nombre, il faut écrire (7,). Vu l'usage qui est généralement fait des parenthèses, ça peut se comprendre, mais ça reste assez déroutant. À noter que 8,9 (sans les parenthèses) est aussi un tuple contenant deux nombres.

Bon, je passe sur l'absence de switch/case, et d'enum ; on s'y fait assez rapidement.

Concernant l'apprentissage de la programmation, c'est Python qui semble être le plus utilisé. C'est encore lui qui est le langage de prédilection lorsque qu'il s'agit de manipuler les ports GPIO d'un Raspberry Pi. C'est donc vers ce langage que je me suis tourné pour un projet d'outil pédagogique (journal dédié) destiné à être utilisé dans le cadre de cours de programmation. Le fait de facilement avoir accès aux mécanismes internes de Python facilite l'écriture d'exercices pour ce genre de cours (ou du moins l'idée que je me fais d'exercices de ce genre). Alors, ce projet n'existe qu'en Python (pour le moment), donc je ne peux le comparer avec d'autres langages de ce point de vue, mais je ne vois pas trop comment faire mieux que Python. J'ai vraiment facilement et relativement élégamment pu résoudre les problématiques liés à ce genre de projets (vais peut-être faire un journal, voire une dépêche, sur le sujet un de ces jours…). Par contre, je me garderais bien de me prononcer sur la pertinence de l'utilisation de Python pour l'apprentissage de la programmation, n'ayant pas assez de recul.

Ne prenez pas ce commentaire pour plus qu'il n'est : un ressenti, donc totalement subjectif. Sachant, en outre, que, malgré toutes les qualités de Python, et des autres langages que j'ai pu essayer, le C++ reste mon langage de prédilection…

Pour nous émanciper des géants du numérique : Zelbinium !

Si, mais, pour les raisons précédemment citées, il s'appuie sur WebKit au lieu de Gecko…

Pour nous émanciper des géants du numérique : Zelbinium !

Le premier lien est l'équivalent d'un man gpio, et le second permet de voir à quoi ressemble la sortie de la commande readall. Ainsi, on peut installer l'utilitaire en connaissance de cause, et non pas juste pour se faire une idée, sans être sûr de vouloir le conserver.

Cet utilitaire n'est pas toujours installé d'office, même avec les distributions dédiées. Il n'était pas installé sur mon ODROID, par exemple.

Pour nous émanciper des géants du numérique : Zelbinium !

Il y a aussi l'utilitaire gpio, installé d'office (il me semble) sur une Raspbian, avec notamment la commande readall, qui permet d'avoir une vue d'ensemble de la configuration et de l'état de chaque port GPIO. On peut voir cette commande en action sur cette vidéo (c'est du Peertube).

Pour nous émanciper des géants du numérique : Zelbinium !

Dans ce cas précis , strchr(…) serait préférable, mais les deux seraient de toute manière plutôt l'équivalent de string.find(…). C'est var in other_var, en tant que construction du langage, qui n'a pas d'équivalent en C…

Pour nous émanciper des géants du numérique : Zelbinium !

C'est bien pour ça qu'il y a ceci…

Comme indiqué dans le journal, le but ce n'est pas d'apprendre Python, mais la programmation en général. Donc, après avoir trouvé la solution pythonesque, un nouvel énoncé leur sera soumis dont la solution ressemble à celle proposée dans le fichier ci-dessus, histoire de les entraîner à écrire des boucles for.

Pour nous émanciper des géants du numérique : Zelbinium !