Découvrir le python – chapitre 3 – list’oire de la vie

Le titre de l’article est une blague par rapport à la chanson naze et bien-pensante du Roi Lion : « C’est l’histoâââââre de la viiiiiiiie ». Ce troisième article de découverte du python a pour sujet principal : les listes.

Je tenais à expliquer cette blague, car quand on explique une blague, elle n’est plus drôle. Mais quand une blague est pas drôle dès le départ et qu’on l’explique, ça devient drôle.

Avant tout, pif paf la solution au devoir du précédent article. C’était plus un travail de géométrie que de programmation. Des fois, on croit qu’on fait un truc et on en fait un autre. C’est comme ça la vie, jeune lecteurtrice. L’histoâââre de la viiiiieeeuuuuu.

De la couleur

Remet-toi sur le site Trinket, ajoute les deux instructions habituelles du début : « import turtle », « turtle.speed(0) ».

Ensuite, tu copie-colles la fonction « dessiner_diams » créée dans l’article précédent (tu peux la récupérer dans la correction du devoir).

Pour finir, ajoute une seule ligne après la fonction, dans le programme principal : « dessiner_diams(0, 0, 50) ». On est devenu des prolos et on fait des petits diamants.

On est des prolos, mais on n’est pas forcément des communistes. On voudrait pouvoir faire des diamants ayant une autre couleur que ce rouge pétaradant.

Tu as certainement déjà repéré la ligne de code de la fonction spécifiant que le diamant est rouge. Pour les anglophonophobes, je rappelle que « red » signifie « rouge ». Indique une autre couleur à la place : « green », « blue », …

C’est top-de-la-housse, mais ça ne permet pas de dessiner des diamants de couleurs différentes.

Alors tu vas appliquer la même méthode que dans l’article précédent, lorsqu’on avait ajouté le paramètre « taille » :

  • Ajoute un paramètre supplémentaire dans la fonction « dessiner_diams ». On va l’appeler « couleur ».
  • Utilise ce paramètre dans le corps de la fonction. À toi de trouver où il faut le mettre et à la place de quoi.
  • Ajoute ce paramètre lorsque tu appelles la fonction, dans ton programme principal.

On va profiter de cette souplesse supplémentaire que tu viens de conférer à ta fonction (lecteurtrice, tu te rends compte que tu con-faire ? Tellement génial). Remplace la ligne du programme principal par ces deux lignes :

dessiner_diams(0, 0, 50, "green")
dessiner_diams(25, 25, 50, "blue")

Et voilà !

Lien vers la solution si t’as perdu tes couleurs.

De la couleur RVB

Les couleurs c’est fun et bigarré, mais c’est chiant de devoir les identifier par des noms, surtout en anglais. C’est un coup à ce que ça parte en bastonnade entre d’éminents chromatologues qui se crêperont l’arc-en-ciel sur la différence entre le cyan et le turquoise. Encore heureux que turtle ne reconnaît pas le fuschia, sinon je vous dis pas le bordel ! Personne ne connaît vraiment ce mot.

Il existe une manière plus standard de définir les couleurs en informatique. On indique trois nombres, correspondant aux quantités des trois couleurs primaires : rouge, vert et bleu.

Je t’entends protester d’ici, lecteurtrice : « han mais n’importe quoi, mon prof de dessin il m’a dit que les couleurs primaires c’est rouge, bleu et jaune ! ». Alors je te répondrai d’écouter ton prof mieux que ça, car il a plutôt dit que les couleurs primaires sont magenta, cyan et jaune. Finalement, je te répondrais que ça dépend si on est en synthèse additive ou en synthèse soustractive. Écris ces termes dans un moteur de recherche si tu veux en savoir plus.

Si tu as joué avec des logiciels de dessins, tu connais déjà les sélecteurs de couleurs. En voici un disponible en ligne : https://lehollandaisvolant.net/tout/tools/color/ .

Choisis la couleur que vu veux et retiens les trois nombres de la ligne « RGB » (Red Green Blue).

Dans ton code python, tu peux écrire ces trois nombres à la place du nom de la couleur. Mais attention, il faut mettre des parenthèses pour les délimiter. Par exemple :

dessiner_diams(0, 0, 50, (42, 234, 69))

« dessiner_diams(0, 0, 50, 42, 234, 69) », ça ne marcherait pas.

Miss Diamond Doll, puisqu’on reste sur les diamants

Tuple et zante ?

Pourquoi il faut des parenthèses en plus ?

La couleur ne doit constituer qu’un seul paramètre. Mais celui-ci peut être de type simple (un texte entre guillemet), ou de type composé.

Ces trois nombres entre parenthèses définissent une valeur de type tuple. « Tuple » est le mot générique pour dire un couple / un triplet / un quadruplet / un n-uplet.

Pour toutes les fonctions de la librairie turtle nécessitant des couleurs dans leurs paramètres, on peut indiquer un texte correspondant à un nom de couleur valide, ou bien un tuple de 3 entiers. Une conversion est effectuée en interne dans turtle.

Les tuples sont des types de valeurs comme les autres, tu peux donc les mettre dans des variables :

ma_couleur = (42, 234, 69)
dessiner_diams(0, 0, 50, ma_couleur)

Et aussi utiliser des variables numériques comme composantes d’un tuple:

le_rouge = 42
le_bleu = 69
# J'ai la flemme de créer la variable pour le vert.
dessiner_diams(0, 0, 50, (le_rouge, 234, le_bleu))

Plus d’infos sur les tuples dans cette chouette documentation : https://courspython.com/tuple.html

Profitons de cette nouvelle connaissance et réalisons un joli dégradé de couleur.

Tu me fais une boucle qui dessine 100 diamants :

  • La coordonnée X varie de 5 en 5, en partant de -200 : -200, -195, …
  • La coordonnée Y reste à 0.
  • La taille reste à 50.
  • La couleur rouge reste au maximum, c’est à dire 255.
  • La couleur verte reste à 0.
  • La couleur bleue varie de 2 en 2, en partant de 50 : 50, 52, 54, …., 246, 248.

Ça donnera un magnifique dégradé :

Lien vers la réponse, si ton cerveau s’est dégradé.

Vous êtes l’éliste de la nation

Tu vas mettre en commentaire ta belle boucle du chapitre précédent, car on va partir sur autre chose. Nous arrivons enfin au sujet majeur de cet article : les listes.

Dans le programme principal, juste après la définition de la fonction dessiner_diams, tu vas créer une liste contenant quelques nombres :

ma_liste = [-70, 38, 45, -20, 113]

Tu peux parcourir cette liste à l’aide d’une boucle. En voici une toute simple, je te laisse deviner ce que ça fait :

for elem in ma_liste:
    print(elem)

On retrouve la même syntaxe que pour les autres boucles : for {bidule} in {truc}:

Sauf que cette fois-ci, le {truc} que tu parcoures n’est pas une fonction « range » qui ne fait que compter. C’est une liste, avec tout et n’importe quoi dedans.

Lecteurtrice, je vois bien, à ton œil mouillé et ton air rébarbatoire, que tu as envie de me poser une question qui dérange :

« Wesh, auteurtrice, c’est quoi l’intérêt d’avoir inventé deux types : les listes et les tuples ? Ils font la même chose : stocker une suite d’éléments. »

Eh bien voilà : les tuples ne peuvent pas changer de contenu. Les listes, si. On peut y ajouter ou enlever des éléments, en remplacer un par un autre, etc.

Re-lecteurtrice, je te revois bien me redemander :

« Re-wesh, à quoi ça sert d’avoir inventé des tuples qu’on ne peut pas changer, si on a déjà les listes, qui font la même chose et qu’en plus on peut changer ? »

C’est pour les performances. Les tuples prennent très peu de place en mémoire et sont très rapides d’accès. Quand on a besoin d’une suite de trucs et qu’on sait qu’on ne la changera pas, on prend un tuple.

Voilà un autre lien avec plein de détails sur les listes : https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232026-creez-des-listes-et-des-tuples-1-2

Si tu ne veux pas tout lire, je te montre très rapidement ce dont tu auras besoin pour la suite :

ma_liste = [-70, 38, 45, -20, 113]
# Accès à un élément
print(ma_liste[2])
# Ajout d'un élément à la fin
ma_liste.append(99)
# Écriture de toute la liste.
print(ma_liste)

Mets ça dans un programme et regarde ce que ça fait. C’est d’une comprenabilité qui ne me semble pas pharaonique.

On peut boucler sur les listes, comme sur les tuples. De manière générale, il y a des tas de choses en commun entre les listes et les tuples, qui se font exactement de la même manière. C’est possible grâce à un concept de programmation appelé le duck typing.

Ça disgresserait trop d’expliquer ce concept dans cet article. Pour ne rien te cacher, je l’ai mentionné juste pour avoir l’occasion de placer cette superbe image :

Si ça fait coin-coin comme un canard, c’est un canard.

List-ception

En informatique, on aime mettre des trucs dans les mêmes trucs : un sous-bloc de code dans un bloc de code, un sous-répertoire dans un répertoire, …

J’ai le plaisir de t’annoncer qu’on peut mettre des listes dans des listes, des tuples dans des tuples, des tuples dans des listes dans des tuples dans des tuples, etc.

Voici une liste avec des tuples dedans :

des_coords = [ 
    (-100, -40), (100, -40), (-80, -70), 
    (80, -70), (-60, -90), (60, -90),
    (-40, -100), (40, -100), (-20, -110), 
    (20, -110), (0, -115),
    (-70, 120), (70, 120),
]

Tu remarqueras qu’on peut l’écrire sur plusieurs lignes, à condition de ne pas oublier le crochet ouvrant au début ni le crochet fermant à la fin, et de respecter l’indentation.

Ajoute cette liste de tuples dans ton programme et fais une boucle dessus.

  • À la première itération, tu récupéreras le tuple (-100, -40), et tu me dessineras un diamant aux coordonnées X=-100 ; Y=-40.
  • À la deuxième itération, tu dessineras au autre diamant en X=100 ; Y=-40.
  • Puis en X=-80 ; Y=-70.
  • etc.

Pour la couleur des diamants, met ce que tu veux. Personnellement, j’ai choisi un espèce de jaune-orangé : (250, 150, 0).

Tu obtiendras un joli sourire de joker !

Why so serious ?

Lien vers la réponse, si t’as plus de cartes joker.

Je return à ma maison

OK lecteurtrice, si tu en es là dans l’article, et que tu as codé tous les exercices avec les doigts nus de tes mains nues, sans trop regarder les réponses, tu as de la motivation et de la comprenitude. J’ai confiance en toi, je sens que tu ne vas pas t’évanouir si je t’apprends DEUX choses différentes dans un même chapitre.

Mets-toi face à moi pour bien recevoir toute ma décharge cognitive.

1)

Une fonction peut renvoyer quelque chose (un nombre, une liste, …). Le code ayant appelé la fonction peut récupérer ce qui a été renvoyé.

Voilà un exemple :

def renvoyer_une_liste():
    print("coucou")
    return [4, 6, 15, 9]
    print("On ne voit pas ce texte.")
    print("Car une fonction s'arrête après un return.")

liste_que_je_recupere = renvoyer_une_liste()
print(liste_que_je_recupere)

Si tu exécute ce bout de code, ça écriras : « coucou », puis « [4, 6, 15, 9] ».

On a le droit d’écrire plusieurs « return » dans une même fonction. Mais dès que l’exécution arrive sur l’un d’eux, la fonction s’arrête, et renvoie ce qui est indiqué.

2)

La fonction turtle.pos() renvoie un tuple de deux éléments, contenant les coordonnées de la position actuelle de la tortue. Tu peux tester comme ceci :

ma_position = turtle.pos()
print(ma_position)

Et maintenant tu vas mettre tout ça en pratique.

  • Au début de la fonction dessiner_diams, tu crées une liste vide. On va l’appeler « coord_des_pointes ».
  • Dans la boucle de la fonction, juste après l’instruction turtle.circle, tu récupères la position actuelle de la tortue.
  • Tu ajoutes cette position dans coord_des_pointes. Celle liste contiendra donc des tuples.
  • À la fin de la fonction, tu « return » coord_des_pointes.
  • Dans le programme principal, tu exécutes une seule fois la fonction dessiner_diams,
    • coordonnées X=0 ; Y=0, taille = 50, couleur = ce que tu veux.
  • Tu récupère la valeur renvoyée par la fonction, et tu la printes.

Ça devrait t’afficher ça dans la sortie standard :

[(0.0, 50.0), (50.0, 0.0), (0.0, -50.0), (-50.0, 0.0)]

Lien vers la solution, en cas de surcharge cognitive.

Je vous emmerde et je return à ma maison

Des diamants dans des diamants

Puisque tu as récupéré des coordonnées, profites-en pour dessiner des diamants avec ! Mais tu les fais un peu plus petits. Une taille de 25, par exemple.

Ça donnera quelque chose dans ce style (même si c’est pas ces couleurs là) :

Est-ce que tu vois ce qui va venir après, lecteurtrice ? Est-ce que tu réalises qu’on est maintenant très proche de l’image finale que je t’ai promise il y a plus de deux mois ?

À chaque fois que tu traces les 4 petits diamants, la fonction renvoie à nouveau les coordonnées de leurs 4 coins. Tu pourrais toutes les récupérer, (16 coordonnées en tout), et dessiner sur chacune d’elles un autre diamant, encore un peu plus petit que les précédents. Ne serait-ce pas fractalement uber-classe ?

Il te reste à régler un petit détail : tu ne récupères pas les 16 coordonnées en un seul coup.

Dans le programme principal, avant la boucle où tu dessines les diamants de taille 25, tu crées une liste vide. On va l’appeler coord_mini_diamants.

À chaque dessin de diamant, tu récupères 4 coordonnées, que tu ajoutes dans coord_mini_diamants. Sais-tu comment on ajoute une liste à la fin d’une autre liste ?

Eh non lecteurtrice, ce n’est pas la fonction « append ». Celle-ci permet d’ajouter un élément simple au bout d’une liste. Pour ajouter une liste au bout d’une liste, on utilise l’addition, tout simplement.

Tu aura donc ceci dans ta boucle :

coord_mini_diamants = coord_mini_diamants + dessiner_diams(x, y, 25, (255, 0, 0)

Une fois que cette liste est remplie, plus qu’à s’en servir.

Et paf, un niveau de diamant supplémentaire :

Lien vers le code, si les diamants ne sont pas tes meilleurs amis.

diamant(diamant(diamant(diamant())))

Pour finir, tu re-appliques la même démarche, pour un dernier niveau supplémentaire.

Je te récapitule le tout :

  • premier diamant : taille = 50, couleur= (128, 0, 0)
  • 4 diamants autour : taille = 25, couleur= (255, 0, 0)
  • 16 diamants autour : taille = 12.5, couleur= (255, 70, 70)
  • 64 diamants autour : taille = 6, couleur= (255, 120, 120)

Le fait de reproduire plusieurs fois la même forme, à d’autres endroits, et de plus en plus petite, me permettrait de te présenter les notions de fractales et de récursivité. D’ailleurs, on pourrait dessiner tous les diamants en une seule et même boucle. Mais je ne vais pas t’embêter avec ça, cet article est déjà assez cerveauphage.

Tout ça pour dire que nous arrivons enfin à notre image finale ! Yiiipiii !

Lien vers la réponse, si tu t’es fait une fracture de la fractale.

C’est tout pour aujourd’hui

Voici inévitablement des devoirs. Pour cette fois, je t’en donne deux !

Le premier est assez facile, c’est une reprise du devoir précédent. Il faut dessiner cet anus de licorne :

Petit indice : tu vas devoir trouver comment tracer des formes remplies de couleur, mais sans le trait noir de délimitation.

Le deuxième :

Là c’est un peu plus dur. Il faut reprendre ce qu’on a fait avant, en annulant le dessin de certain diamants. Le tout est de savoir lesquels. Un coup c’est celui de droite, un coup celui du haut, …

Tu vas peut-être devoir apprendre par toi-même à utiliser une notion que je n’ai pas du tout présentée : le branchement conditionnel, if-then-else.

 

Et la suite ?

La librairie turtle permet également de créer des animations. Dans Trinket, on peut faire quelque chose comme ça :

Je pourrais donc te pondre un ou deux articles là-dessus, lecteurtrice. Mais je ne sais pas si ça vaut le coup. Je voudrais écrire d’autres trucs et me lancer dans d’autres projets.

J’ai mis cette série d’article de découverte du python sur mon compte Linkedin (vous ne savez pas lequel c’est, mais vous n’en avez pas besoin). Dans l’ensemble, j’ai eu des retours très aléatoires :

  • zéro commentaire dans ce blog, mais ça j’y suis habitué,
  • plein de commentaires et repartages Linkedin pour le premier article,
  • un seul repartage (de mon super-pote) pour le second article.

Je suis un peu perplexe. Je ne sais pas si c’est les gens qui ne me répondent rien parce que je ne les intéresse pas, ou si c’est Linkedin qui ne met pas mes articles dans le fil d’actualité des gens pour une raison obscure (le fait d’avoir placé le mot « fouetter » lorsque j’ai décrit les sévices corporels destinés aux personnes ne faisant pas leur devoirs ?)

Et désolé, il n’y a pas autant de blagues et de jeux de mots débile dans cet article. Un réajustement effectué par mon inconscient ? Je ne sais pas.

Je vais attendre les retours, mais si j’en ai à nouveau aussi peu, je ne me prendrais pas la tête. Le tout dernier article de la série (s’il y en a un) sera du code brut : les corrections des devoirs et l’animation.

Tchôrp.

Découvrir la programmation python et faire des petits dessins, là tout de suite

Hey !

Alors comme ça tu veux essayer la programmation et tu ne sais pas par où commencer ? Tu as joué un peu avec des formules Excel et tu as trouvé ça relou ? Tu as pris peur devant la quantité faramineuse de case à cocher et de Giga-octets nécessaires à l’installation de Visual Studio ? On s’est moqué de toi quand tu as dit que le C++ était mieux que le HTML ? Allez, viens, t’as cliqué à la bonne porte. J’ai filé des cours de python à des jeunes en collèges et lycées, et j’ai presque eu l’impression d’avoir été intéressant. Autant t’en faire profiter !

Non-installation des outils nécessaires

Quand on débute en programmation, il faut s’inscrire sur des sites (github, stackoverflow, …), installer des interpréteurs, des compilateurs et un tas d’autres bronxs. Sauf que toi, tu veux pas forcément t’y mettre sérieusement, tu veux juste découvrir pour savoir si ça vaudra le coup de t’y mettre sérieusement. Tkt, lecteurtrice, je suis là pour ça.

Va voir par ici : https://trinket.io/python (ouvre le lien dans un nouvel onglet, car tu auras besoin de passer de l’un à l’autre).

C’est un petit environnement d’exécution en python, rien que pour toi. « Python » est le nom d’un serpent, mais aussi d’un langage de programmation.

Dans la partie gauche, c’est le code que tu écris, dans la partie droite, le résultat de l’exécution de ce code. T’as vu lecteurtrice ? J’ai utilisé le mot « code ». Ça veut dire exactement la même chose que « programme », mais ça fait plus expert. Hésite pas à utiliser ce mot.

Un premier exemple s’est déjà exécuté. On s’en fout. Efface tout le texte de la partie gauche et met seulement ces trois lignes :

import turtle
turtle.forward(50)
turtle.left(90)

En haut de la fenêtre se trouve un bouton « Play » (une flèche vers la droite), clique dessus. Si y’a pas, t’as un bouton « Stop » à la place, clique puis reclique dessus.

Devant tes yeux ébahis, un trait va se tracer.

Tant qu’à faire, clique sur le bouton « Expand » en bas de la fenêtre, ce sera plus pratique.

Mais que sont donc ces trois lignes que tu as copié-collées ?

La première sert à importer la librairie de code intitulée « turtle ». C’est ce qui te permet de tracer des petits dessins.

Si t’es un vieux ou une vieille, lecteurtrice, tu te souviens peut-être du plan « Informatique Pour Tous » et surtout du langage « Logo ». Turtle en est inspiré.

Le principe, c’est que la petite flèche noire dans la partie droite représente une tortue (ou n’importe quelle autre animal si tes goûts en matière de zoophilie sont différents). Tu la diriges avec des instructions de code.

  • « turtle.forward(50) » signifie que tu la fais avancer de 50 pixels.
  • « turtle.left(90) » signifie que tu la fais tourner de 90 degrés vers la gauche.

Juste pour montrer que tu as bien compris, tu vas changer le code pour me dessiner un beau carré de 50 pixels de côté. T’as juste à re-écrire trois fois de plus les deux dernières lignes. Fais un copier-coller, ça passe crême. Ne recopie pas « import turtle », qui n’a besoin d’être écrit qu’une seule fois au début. Appuie sur Play pour relancer le programme.

Ça y’est, t’imprimes ?

On peut aussi écrire du texte. À la fin de ton programme, ajoute la ligne :

print("yo ho ho ho. lolilol")

Le carré va se redessiner et du texte va s’afficher dans la partie juste en-dessous.

La fonction « print » affiche en bas à droite le texte que tu lui indiques. Ça s’appelle la sortie standard. C’est un truc de base que tu as tout le temps, même avec autre chose que le python.

En général, quand on découvre la programmation, on ne commence qu’avec ça, on ne dessine pas avec turtle. Du coup, on se retrouve à faire des exercices poucraves, genre pisser la suite de Fibona-qui-chie ou sortir la solution d’une équation du premier degré. C’est chiant. Nous on fais pas ça, nous on met des paillettes dans la life, t’as vu ?

Quand tu programmes, que tu sois débutant ou pas, il y a plein de fois où tu écris des trucs pétés qui déclenchent des erreurs. Ça fait partie du jeu. Dans le bel environnement de développement que je te propose, les erreurs s’affichent en bas de la fenêtre, et la ligne de code pétée est surlignée en rouge. On va tester ça tout de suite. Après le print, tu écris n’importe quoi. Vas-y lâche toi, fais pas ta/ton mijauré·e. (Wesh ! T’as vu lecteurtrice ? Je fais de l’écriture inclusive, c’est à la mode).

Appuie sur Play, et tu verras un message outrageusement irrespectueux, genre « NameError: nanani » ou « Bad input: nianiania ».

Les messages d’erreurs sont plus ou moins explicites, selon ton niveau de connaissance, la débilité que tu as écrite et la complexité de ton programme. Des fois ça peut aider de chercher sur internet ce que ça veut dire. Des fois pas. Tkt, lecteurtrice, tout au long de ce tuto, je t’ai mis des exemples de code qui fonctionnent. Si t’es grave dans la derche, ça t’aidera. Mais essaye à chaque fois de trouver la réponse par toi-même.

L’autre truc rigolo, c’est quand ton programme n’a aucune erreur, mais qu’il ne fait pas du tout ce que tu veux. Dans ce cas, met des « print ». Ça te permet de voir par où passe l’exécution, d’afficher le contenu de tes variables, etc.

On va tester ça tout de suite. Ajoute ça à la fin de ton programme :

x = 5
print("Valeur de x")
print(x)

Tu peux aussi écrire plusieurs trucs sur une même ligne, en séparant chaque valeur par une virgule. Ajoute aussi ça :

print("Valeur de x :", x)

Et rond et rond

On continue avec un truc simple. En plus du carré, tu vas me dessiner un cercle de rayon 60 pixels. Lorsque ton programme s’exécute, on doit voir ça :

Tu sais pas comment on dessine un cercle ? Mince alors. Eh bien, cherche. Va voir par là si j’essuie : https://docs.python.org/3.8/library/turtle.html#turtle.circle

C’est aussi ça, la prog. Tu passes ton temps à chercher comment on fait certains trucs, parce qu’on ne peut pas retenir tous les trucs.

Ensuite, au lieu d’un cercle entier, tu me dessines juste un tiers de cercle. Faut que ça donne ça :

Pour t’aider, re-zy-va voir le lien internet sus-cité.

Comme promis, lecteurtrice, voilà un lien vers la réponse, à n’utiliser qu’en cas d’extrême urgence mondiale, si tu n’arrive pas à trouver par toi-même.

Humeur variable

Mine de rien, on a fait un truc super important dans le chapitre pré-précedent, avec l’instruction « x = 5 ». On a déclaré une variable.

Ooooohhhhh.

Définition : une variable est un truc dans lequel tu mets le machin que tu veux. Tu peux ensuite réutiliser le truc, ça fait comme si c’était le machin. Débrouille-toi avec ça.

Le signe « égal » utilisé n’a pas la même signification qu’en maths. C’est une affectation et pas une égalité. Ce sont deux notions différentes, mais qui existent toutes les deux en programmation. On verra ça plus tard.

Dans ta tête, quand tu vois écrit « x = 5 », tu peux te dire « x prend la valeur de 5 », ou bien « x devient 5 ». Ce sera plus exact que « x égal 5 ».

Tu peux aussi te faire dans ta tête la voix française de Jim Carrey. Sérieusement, ça aide.

Si tu veux plus de détails sur les variables, va voir ce tutoriel. Il est assez bien fichu, y compris les chapitres après, sur les listes, les tuples, les fonctions… Ça pourrait te servir pour la suite.

On est pas chez ces ringards de matheux, t’as le droit d’avoir des noms de variables de plusieurs lettres, à condition qu’il n’y ait pas d’espace. Par exemple : « ma_super_variable = 5 ».

Ton environnement de dev a aussi un mode console, mais je t’embête pas avec ça pour l’instant. Par contre, un truc utile, au lieu de cliquer sur Play, tu peux utiliser le raccourci Ctrl+Entrée. Ça exécute ton code.

Si tu veux avoir l’air d’un vrai programmeur qui a des gonades, utilise des raccourcis claviers plutôt que ta souris. (Wesh lecteurtrice ! T’as vu ? Écriture inclusive avec le mot « gonades »). Comme t’as souvent les mains sur le clavier pour écrire du code, vaut mieux essayer de tout faire avec le clavier plutôt que de perdre une demi-seconde à attraper la souris.

Autre bidouille, spécifique à turtle. Au début de ton programme, juste après l’instruction « import », tu peux ajouter la ligne « turtle.speed(0) ».

La tortue dessinera ses traits et ses cercles plus vite. Tu me remercieras quand tu en seras à exécuter ton code pour la vingtième fois parce que tu seras en train d’essayer de faire marcher quelque chose qui ne veut pas marcher.

Une boucle pour une spirale

Commence par nettoyer le bazar des chapitres précédents. Supprime toutes les instructions de dessins : « turtle.forward », « turtle.left » et « turtle.circle ». Si tu tiens absolument à garder ces premiers blablablutiements, sauvegarde-les dans un petit fichier texte. Ou sinon, laisse-les où ils sont, mais en commentaire. Il suffit d’écrire un caractère dièse « # » au début de la ligne.

Très utile les commentaires. Ça peut servir à expliquer des choses directement dans le programme. Tu peux aussi écrire ton autobiographie.

Si je te fais enlever tout ça, c’est pour repartir sur une zone de dessin propre. Parce qu’on va faire du fun.

Des spirales comme la coiffure de princesse Leia

Si t’es pas trop vieux ou vieille, lecteurtrice, tu as certainement entendu l’expression de langage de jeune : « être en boucle sur quelque chose ». Ça vient de l’informatique.

Sans plus attendre, copie-colle moi cette ligne à la fin de ton programme :

for compteur in range(11):print(compteur * 8)

Tu exécutes, et ça écrit la table de 8 dans la sortie standard.

Cette ligne de code est à lire en deux parties, séparée par le caractère « : ». La première partie indique que tu veux faire une boucle, c’est à dire exécuter plusieurs fois la même chose.

Le « 11 » indique que cette boucle s’exécutera 11 fois, en comptant de 0 à 10. Ça a l’air crétin de commencer à compter à partir de zéro, mais ça se justifie. Je prendrais le temps de t’expliquer plus tard, quand tes poils auront poussés, jeune lecteurtrice.

Le morceau de code après le deux-points, c’est le contenu de ta boucle. C’est à dire l’instruction que tu veux exécuter plusieurs fois. Tu la connais déjà, c’est un « print ».

Le caractère étoile « * » signifie simplement la multiplication. En maths, la multiplication est notée par une croix, mais ce caractère n’existait pas sur les premiers ordinateurs. D’ailleurs, ces crétins de matheux n’utilisent même pas la croix, ils mettent rien du tout. « 2a » signifie « 2 multiplié par a ».

Déso, mais le caractère rien-du-tout ça existe pas, même sur les ordinateurs récents. Qu’est-ce qu’ils sont cons ces matheux.

Revenons aux boucles. Celles-ci sont gentilles. En plus de répéter un truc, elles te donnent gratochement une variable. Ici, on l’a appelé « compteur ». Celle-ci change automatiquement de valeur à chaque passage de la boucle.

Ça fait comme si t’avais écrit :

compteur = 0
print(compteur * 8)
compteur = 1
print(compteur * 8)
compteur = 2
print(compteur * 8)
...
compteur = 10
print(compteur * 8)

Ceci étant expliqué, on est bien d’accord que la table de 8, c’est des maths et c’est ringardos. Nous on veut du fun. On va dessiner une putain de spirale !

Tu sais comment ça se dessine, lecteurtrice ? Il suffit de tracer des morceaux de cercles de plus en plus grand. On dit qu’on fait des tiers de cercles, avec des rayons qui augmentent de 10 pixels en 10 pixels. On en fait 15.

Si t’es débile, lecteurtrice, tu vas faire ça :

turtle.circle(0, 120)
turtle.circle(10, 120)
turtle.circle(20, 120)
...

Mais tu vaux mieux que ça et tu me le fais sous forme d’une boucle, Okaye ?

Le dessin tracé ressemblera à ça :

Le lien vers la réponse, si jamais tu galères.

Une spirale qui grossit et des blocs de code

Sais-tu qu’on peut changer la taille du trait ? Mets-nous l’instruction « turtle.pensize(5) » juste avant ta boucle. Voilà une jolie spirale plus épaisse. Le nombre indiqué correspond à une taille en pixel. Évite de mettre trop gros, ça fera des pâtés moches. Le pensize doit être petit. D’ailleurs « pensize » est un anagramme de « ze penis ».

Soyons over-fun. Tu vas me dessiner une spirale de plus en plus épaisse. Le trait pourrait varier de 0 à 14 pixels, par exemple. Ça tombe bien, ta boucle s’exécute déjà avec un compteur qui va de 0 à 14.

Et là on arrive à une notion très importante en programmation (python ou autre) : les blocs de code.

Un programme est un gros bloc de code, avec plusieurs instructions dedans.

Dans un bloc de code, il peut y avoir des sous-blocs, eux-mêmes pouvant contenir des sous-sous-blocs, etc. Un peu comme ces ringards de matheux quand ils imbriquent des parenthèses. Zou, un exemple.

3 * ((1 + 6) * 2) + 4 * (2 + 5) – 1
Cette expression contient deux sous-blocs : ((1 + 6) * 2) et (2 + 5).
Le premier sous-bloc contient un sous-sous bloc : (1 + 6)

La comparaison s’arrête là. En maths, on évalue en premier les sous-blocs les plus profonds. En programmation, on commence au début, et on avance en rentrant (ou pas) dans les sous-blocs.

Une boucle annonce un sous-bloc, qu’elle exécutera plusieurs fois. Dans le chapitre précédent, ton sous-bloc n’avait qu’une seule instruction : « turtle.circle(compteur * 10, 120) ».

Chaque début et fin de sous-bloc doit être clairement indiqué dans le programme. Dans les langages C et Javascript, on utilise pour ça des accolades « {} », en LISP, des parenthèses « () », en Pascal, les mots « begin » et « end », etc.

Pour que le programme soit plus facilement lisible, on indente les blocs. Toutes les instructions d’un sous-bloc doivent être écrites avec un décalage de quelques espaces au début (en général on en met 4). Les instructions d’un sous-sous-bloc doivent être décalée deux fois, soit 8 espaces, et ainsi de suite. Quand on sort d’un bloc, on enlève un décalage d’indentation.

Il y a des tas de gens qui ne respectent pas cette mise en forme. Leurs programmes sont alors beaucoup moins lisibles. Si tu rencontres ce type de personnes, il est de ton devoir de les insulter et les stigmatiser.

Tu as sûrement déjà vu des images corporate bullshit montrant un écran d’ordinateur avec des lignes de code. C’est hype, swag, geek, hacker et tagada-tsoin-tsoin.

T’as vu lecteurtrice comment sont organisées ces petites lignes ? Ça se décale, puis ça se recale, se redécale, se rerecale. C’est ça l’indentation.

Et en python, comment donc marque-t-on les débuts et fin de blocs ?

Tu vas rire lecteurtrice, c’est par l’indentation elle-même ! Quand tu veux que des lignes de code soient dans un sous-bloc, tu leur mets des espaces au début. Quand ton sous-bloc se termine, tu écris la ligne suivante sans les espaces.

C’est un peu déroutant, mais ça a un très gros avantage. Ton code est obligé d’être bien présenté. En python, tu ne pourras jamais te faire insulter ou stigmatiser parce que tu n’auras pas respecté les règles d’indentation. (On pourra toutefois t’humilier pour plein d’autres raisons).

Les éditeurs de texte conçus pour la programmation prennent en compte cette particularité des indentations. Essayons ça tout de suite. Retourne à ton programme et copie-colle ce texte, sans oublier les deux-points à la fin : « for compteur in range(15): » , puis tu appuies sur Entrée. Ton curseur va à la ligne d’en dessous, mais pouf ! Il s’est décalé de 2 espaces ! Écrit un truc puis réappuie sur Entrée, ça restera décalé.

Quand tu as fini ton bloc, appuies sur backspace, ça enlève les deux espaces d’un coup, et tu retournes au bloc de code supérieur.

Dans l’environnement que je t’ai proposé, une indentation est représentée par 2 espaces. Ailleurs, ce sera 4, ou 8, ou une tabulation. Il y a des discussions sans fin entre les développeurs pour savoir s’il vaut mieux indenter avec des espaces ou des tabulations. Je ne t’en parle pas maintenant, tu n’es pas encore assez mature pour réaliser à quel point les développeurs peuvent avoir des discussions immatures.

Assez discuté, au boulot ! Tu me fais cette boucle, avec un sous-bloc de deux instructions. La première est un « pensize », la seconde un « circle ».

Ça doit donner un truc comme ça.

Lien vers la réponse si c’est la hass pour toi.

Ce sera tout pour aujourd’hui !

J’espère que ça t’as plu lecteurtrice. To be continued le mois prochain. On fera un dessin comme ça :

En attendant, voici tes devoirs. Essaye de me faire un dessin comme ça :

Je te donne pas le code. Tu te débrouilles. C’est réalisable avec les notions que je viens d’expliquer. Deux petits indices, quand même :

– On peut faire des boucles imbriquées, c’est à dire une boucle dans une boucle. Pense à rajouter une indentation (un décalage d’espace au début de la ligne) à chaque fois que tu rentres dans une nouvelle boucle. Et utilise un nom de variable différent pour chaque boucle, sinon ça va confusionner.

– Les tracés de cercle (et de morceaux de cercle) dépendent de l’orientation initiale de la tortue. Tu peux tester ça vite fait : écrit un programme qui fait uniquement « turtle.circle(60, 120) », puis ajoute juste avant l’instruction « turtle.left(180) ». Le morceau de cercle changera de sens.

Un dernier conseil : n’écris pas trop de code d’un coup. Tu rajoutes quelques lignes, tu appuies sur Play pour vérifier que ça swagge, tu rajoutes ou modifies quelques autres lignes, tu retestes, etc. Si t’écris trop d’un coup et que ça plante quand tu testes, ce sera plus difficile de trouver où que c’est que ça merdouille.

Comme je suis gentil et fun, tu auras le la réponse à l’exercice dans mon prochain article.

Ook ook à toi, lecteurtrice !

*Drop du clavier et je m’en vais comme un prince.

L’expression du vide dans les langages de programmation

Bonjour. Je suis un chercheur du CNRS, ou d’un quelconque organisme du même drapeau. Je travaille sur la théorie du langage, la théorie des types, et autres acabits. Je suis très généreux de mes émoluments intellectuels, et ai à cœur de les partager avec le monde entier. Voici un article totalement inutile, donc indispensable, que j’ai écrit pour la revue scientifique « Geekatorial considerations & Neuronal branling ».

Moi au CNRS, lors d'une recherche documentaire

Moi au CNRS, lors d’une recherche documentaire

Qu’appelle-je l’expression du vide ?

Afin de répondre à cette question,  je vous propose de répondre à la question inverse. Que n’appelle-je-pas l’expression du vide ?

D’aucuns feront la remarque que répondre à une question inverse ne répond pas DU TOUT à la question initiale. Je m’en fous, je suis un théoricien du langage, je fais ce que je veux, c’est quand même pas vous qu’allez m’apprendre mon métier, non mais merde quoi, je suis du CNRS, j’ai fait des études moi, je diplômes. Donc aux aucuns qui font cette remarque, je réponds : « restez aucuns, et ne devenez pas quelqu’uns, vous êtes le vide. »

Bien.

Exemples de ce que n’est pas l’expression du vide dans un langage de programmation :

  • Une variable numérique contenant la valeur 0
  • Une variable booléenne contenant la valeur False
  • Une chaîne de caractère vide
  • Un tableau ou une liste contenant 0 élément

Pourquoi cela ? Parce que ces variables ont des types spécifiques, ce qui exprime déjà quelque chose. Si votre variable numérique est censée représenter une quantité de carottes, la valeur 0 exprime : « Ici, il n’y a pas de carottes ». Ce n’est pas tout à fait la même chose que d’exprimer « Ici, il n’y a rien ». Dans « il n’y a pas de carottes », on sous-entend qu’il pourrait y en avoir. Et c’est déjà l’expression de quelque chose de particulier. Donc l’expression de pas-de-vide.

Votre booléen exprime qu’une certaine proposition est vraie ou fausse. Il n’y a donc pas rien, puisqu’il y a une proposition, peu importe laquelle. Votre chaîne de caractère vide exprime « il n’y a pas de texte ». Mais il y a une chaîne de caractères. Votre tableau vide exprime : « il n’y a pas d’éléments dans ce tableau ». Mais il y a un tableau. Etc.

Dans : « Ici, il n’y a rien », le seul sous-entendu, c’est « Ici, il pourrait y avoir quelque chose ». Oui mais quoi ? On ne sait pas. N’importe quoi. Le premier bidule qui se présente. Et le contraire du premier bidule qui se présente, c’est bien « rien du tout ». Donc « Ici, il n’y a rien » est bien l’expression du vide. Voili voilà.

On admet donc comme prédicat que l’expression du vide ne peut pas être une valeur spécifique d’une variable ayant un type défini.

Des fois y’aura besoin de décocher ce prédicat, on verra ça le moment venu.

Mais encore ?

L’expression du vide n’est pas un commentaire dans le code. Du point de vue de la machine, les commentaires sont totalement ignorés. C’est « parler pour ne rien dire ». Ce n’est pas « parler pour dire qu’il n’y a rien ici ».

Raymond Devos : "Quand j'ai rien à dire, je veux qu'on le sache"

Raymond Devos : « quand je n’ai rien à dire, je veux qu’on le sache »

L’expression du vide n’est pas non plus le vide lui-même. Le vide, ce serait un fichier de code vide, ou plus localement, une ligne vide dans un fichier de code, ou encore plus localement, des espaces à la fin d’une ligne de code.

Le vide c’est « ne pas parler ». Ce n’est pas « parler pour dire qu’il n’y a rien ici ».

Mais assez parlé dans le vide, et voyons quelles sont les possibilités d’exprimer le vide.

Le mot-clé void

« void » est utilisé dans les langages de programmation de bourgeois, tel que le C, le C++, le Java … C’est le nom d’un type. Au même titre que int est un nom de type pour une variable numérique. Sauf que void est un type avec rien dedans. Pas de valeur, que d’alle.

Dans ces langages, les fonctions renvoient toujours quelque chose. Lorsqu’elles ne renvoient rien, elles renvoient une variable de type void. On aurait pu appeler ce genre de fonction des procédures, comme dans le langage Pascal, mais les inventeurs du C sont des bourgeois marrants.

On a donc bien ici une expression de vide : Ici [à l’endroit où on pourrait récupérer une donnée renvoyée par une fonction], il n’y a rien ». Qu’est-ce qu’il pourrait y avoir à la place ? On ne sait pas, puisqu’on a dit que le type lui-même était le vide. Si on veut mettre autre chose, ça pourrait être tout et n’importe quoi.

Dakkath le kilrathi : "The void ! the void !"

Dakkath le kilrathi : « The void ! the void ! »

On peut également utiliser « void » pour déclarer un pointeur vers un truc qu’on sait pas ce que c’est.

void *p = &quelqueChose;

Mais cet exemple n’est pas une expression de vide, puisque le pointeur pointe sur quelque chose. De quel type ce quelque chose est ? On sait pas. C’est le type vide. Certes. Mais « ici, il y a bien quelque chose ».

Fun fact : le pointeur « void * » est le seul moyen, en C, d’obtenir l’adresse mémoire d’une fonction.

int fonction_a_la_con() {
    return 69; 
}
void *pointeur_fonction = &fonction_a_la_con; 
// exécution de la fonction pointée par le pointeur.
// Un pointeur sachant pointer...
(*pointeur_fonction)();

On aurait pu imaginer l’existence d’un type spécifique, définissant une fonction. Quelque chose comme func. Et on aurait écrit :

func *pointeur_fonction = &fonction_a_la_con;

Mais non, on n’a pas ce genre de chose. Pourquoi ? Parce que le C est un langage de bourgeois, tout simplement.

Edit 2013-10-01 : Je me suis un peu trompé concernant les pointeurs de fonction en C. Voir le commentaire de mon ami Pudbou.

On n’en a pas fini avec les pointeurs « void * ». Y’aura une surprise un peu plus loin.

Et sinon, en javascript, il existe carrément la fonction void(). C’est une fonction qui ne fait rien, à part évaluer les arguments qu’on lui passe, ou quelque chose de ce genre. J’ai pas tout compris. En javascript, je suis pas champion. Mais on voit cette fonction dans certains sites web. Passez votre curseur de souris sur un lien un peu bizarre et vous verrez, dans la barre d’état de votre navigateur, le texte sybillin : « javascript:void() ». Merci gentil navigateur, tout le monde s’en fout.

Plus de blabla sur void dans l’inévitable (de chevet) lien kiwi-pédé (http:// fr.wikipedia.org/wiki/Void).

le mot-clé NULL

Toujours dans les langages de bourgeois, le mot-clé NULL est une valeur spécifique qu’on peut attribuer à un pointeur, pour dire qu’il ne pointe sur rien.

int *a = NULL;

Mais cette exemple n’est pas une expression de vide. « Ici, il n’y a rien ». Certes. Mais si y’avait quelque chose, on aurait quoi ? Un entier. On a explicitement précisé ce qu’on pourrait avoir à la place du vide.

Vous pensez à ce que pense ?

Oui ! Une levrette !!!

Mais non bande de petits cochons. Et si on combinait les deux ?

void *p = NULL;

Surprise !!! Voici l’expression du vide dans son excellence. « Ici, il n’y a rien. Ce qu’on pourrait avoir à la place, c’est tout et n’importe quoi. »

Dirigeons-nous maintenant vers un autre langage. Un qu’est pas pour les bourgeois. Un qu’est pour les anarcho-patchworkistes : le PHP.

Eh bien figurez-vous qu’en PHP, toutes les variables valent initialement NULL. Même celles qu’on n’a pas définies. Il s’agit d’une confusion entre l’expression du vide et l’indéfini. « Il n’y a rien ici » s’énonce de la même manière que : « je n’ai encore rien dit à propos de ici ». Je trouve cela étrange, voire carrément stupide.

Re kiwi-pédé (http:// fr.wikipedia.org/wiki/NULL).

D’autre part, dans ce joyeux langage de petits enfants innocents qu’est le Pascal, NULL se dit « nil », mais on l’utilise de la même manière que le NULL du C. Dans d’autres langages que je ne connais pas, on dit « null », en minuscunulles.

Les égyptiens codent en Pascal, car ils ont le Nil

Les égyptiens codent en Pascal, car ils ont le Nil

L’expression du vide dans les systèmes de fichiers

Un système de fichier n’est pas vraiment un langage de programmation. Mais ce que je vous propose ici est un petit paragraphe interludaire.

Un terre-lude ?

Dans un système de fichier, l’expression du vide, c’est tout simplement un fichier vide. 0 octets. Paf. Mais il y a plus rigolo. Il existe le « trou noir », qui absorbe tout ce qui s’en approche.

Le trou noir est un fichier symbolique, c’est à dire un truc qui se comporte plus ou moins comme un fichier, mais qui, physiquement, ne stocke pas d’octets sur le disque dur. Le trou noir fait disparaître tout ce qu’on écrit dedans. Il sert à balancer à la poubelle du blabla de sortie (standard ou erreur) dont on n’aurait rien à foutre.

Dans le monde Unix, ce fichier est situé à l’emplacement /dev/null. Chez Windows, il s’appelle plus simplement NUL.

En guise de dernier soubresaut interludaire, je mentionnerais le fichier Windows CON, permettant de rediriger du blabla de sortie vers la console. Alors, votre Windows, il est NUL ou il est CON ? Ha ha ha.

Le Perl

Perl, au même titre que le PHP, est un langage de programmation pour anarcho-patchworkistes. Mais à tendance hyéroglyphoïdale.

Perl = langage pour faire caca des perles

Perl = langage pour faire caca des perles

Dans ce langage, point de null ni de void, mais la possibilité d’indéfinir des variables. Ça donne quelque chose de ce style :

$a = undef;
#ou bien :
undef($a);
if (defined $a) { ... }

Et ça peut permettre de virer les éléments d’un tableau. (Ou pas, car y’a aussi l’instruction « delete » pour ça). Enfin j’y connais rien, et je m’en fous total du Perl. C’est un langage moche et incompréhensible.

On y retrouve, à priori, la même confusion entre le vide et l’indéfini. D’où le côté anarcho-patchworkiste.

Le Lisp :

Il s’agit d’un langage d’une étrange pureté. Mon collègue penseur, l’éminent geekologue Randall Munroe, de l’université blogalienne de xkcd, nous précise collégialement que ce pourrait être le langage qu’a utilisé Dieu pour coder le monde réel (http:// xkcd.com/224/). Ce n’est pas mon avis, mais ce n’est pas le sujet.

LISP signifie LISt Processing : la plupart des actions se font donc avec des listes. La valeur booléenne True s’écrit simplement « T ». La valeur False s’écrit « NIL ». Sauf que NIL signifie également : « une liste vide ».

L’opérateur « null » permet de savoir si quelque chose est NIL ou pas. (null A) renvoie T si A est vide, et renvoie NIL si A n’est pas vide.

Le Lisp comporte également l’ultra-classique opérateur « not » (inversion d’un booléen). (not A) renvoie T si A est faux, et renvoie NIL si A n’est pas faux.

C'est pas faux.

C’est pas faux.

Or, comme « liste vide » = « faux », on s’aperçoit que les opérateurs « null » et « not » effectuent exactement la même chose. C’est pas rigolo ça ? Dans le moteur d’interprétation du Lisp, ça pointe sur le même code. Moi je trouve ça super.

D’autre part, nous avons ici un contre-exemple de ce que je disais au début. L’expression du vide se fait par le biais d’une valeur spécifique d’une variable ayant un type spécifique.

Interlude : Ø

Le langage mathématique est presque un langage de programmation, bien qu’il manipule des valeurs sorties de mon cul, tel que Pi ou e. Il possède lui aussi son expression du vide. Il s’agit de l’ensemble vide : Ø. Un O barré.

L’origine de ce symbole nous vient de la Grèce antique (à l’époque où le pays avait encore de l’argent). Il représente le cul cousu de Pythagore, qui refusait de se faire enculer par ses amis. Pourtant ils étaient grecs.

Et puisqu’on parle de cul et que c’est interlude :

Et sinon, dans les langages de programmation qui veulent simuler des trucs de matheux, on trouve la valeur NaN (Not A Number). C’est pas tout à fait le vide, puisque c’est « du vide qui aurait pu être un nombre », mais c’est fun quand même. Pour l’obtenir, rien de plus simple : une bonne vieille division par 0 de la mort.

Nan-Nan-Nan-nanère (http:// fr.wikipedia.org/wiki/NaN)

Visual Basic

Je l’ai déjà dit dans une autre vie (vous étiez pas encore là) : le Visual Basic est à la programmation ce que la vulvovaginite est à la sexualité : un truc vraiment sale.

Ce fabuleux langage posède une foultitude de mots rigolos. Ça ne sert pas à grand chose, mais qu’est-ce qu’on s’amuse !

Nothing est l’expression du vide, mais seulement pour les variables objet. (Donc pas totalement une expression de vide). À noter qu’on ne peut pas tester la condition « If machin = Nothing ». Il faut tester « If machin is Nothing ». Pourquoi ? On ne sait pas trop.

Le mot Empty est l’expression du vide, pour le type Variant. C’est à dire le type « tout et n’importe quoi ». On a donc là une expression de vide assez complète. Cependant, Empty est considéré comme égal à 0, ainsi que égal à une chaîne vide. Bizarre, oui.

Toujours pour un Variant, le mot Null est l’expression de l’inconnu (pas du vide). Le Null n’est pas considéré comme égal à 0, ni à une chaîne vide, ni à Empty, ni même à un autre Null. Là encore, il faut tester « If machin is Null ».

Le mot Missing permet juste de savoir si un paramètre optionnel a été passé à une fonction, ou pas. Enfin que pour les Variant. Sinon, on a la valeur par défaut du paramètre selon son type.

Je ne trouve pas d’explication à tout cela.

Mais il y a plus de détails par ici (http:// allenbrowne.com/vba-NothingEmpty.html).

Le chocolat, ce n'est pas sale, contrairement au Visual Basic.

Le chocolat, ce n’est pas sale, contrairement au Visual Basic.

Les types nullables

Restons chez Microsoft, avec leur vision, toujours aussi folklorique, de la programmation. On nous y propose une petite curiosité assez saugrenue : le type que-on-a-clairement-défini-lequel-c-etait-sauf-que-en-fait-il-peut-être-nul.

Ça donne ça :

//Déclaration
int? blorp = 5;
// On peut assigner null, ou une valeur numérique
// à la variable blorp
blorp = 4;
blorp = null;
// blarg = blorp, sauf si blarg est null,
// auquel cas blarg = -1.
int blarg = blorp ?? -1

Pourquoi pas. Ça peut servir…

BrainFuck

Ce langage est trop simple, et ne permet pas d’exprimer le vide.

Le Korn shell, et autres langages de script moches

À ma connaissance, on ne peut pas non plus exprimer le vide avec ces trucs moches. En fait, toutes les variables sont des chaînes de caractères. Lorsque l’une d’elle est vide ou indéfinie, c’est une chaîne vide, tout simplement. Ce qui peut amener des tas de situations bien marrantes.

Exemple. Instruction de copie de fichier, à laquelle on passe des variables en paramètre :

cp ${SOURCE} ${DESTINATION} ${OPTION}

Korn in the shell ? Nichons in the shell ?

Korn in the shell ? Nichons in the shell ?

Outre le fait qu’il faille écrire trois caractères inutiles et moches chaque fois qu’on veut mentionner une variable, on constate ici un truc marrant. Si on a oublié de définir DESTINATION, l’interpréteur le remplace par une chaîne vide, mais aucune erreur ne sera détectée. Le shell de merde va donc stupidement décaler les paramètres. On se retrouvera à copier un fichier vers ${OPTION}, et non vers ${DESTINATION}. N’oubliez pas de nettoyer le bordel que vous aurez foutu sur le disque après tout ça.

Le python

Comme vous le savez, le python est le meilleur langage du monde entier. On peut même programmer des jeux vidéos avec.

On peut y exprimer le vide de manière simple et explicite : le mot-clé None.

Une variable non définie ne vaut pas None. Elle est explicitement pas définie, et provoque une erreur lorsqu’on essaie de l’utiliser quelque part.

Le python est un langage fortement typé. Ça a pas l’air comme ça, parce qu’on peut affecter n’importe quoi à n’importe quelle variable n’importe quand. Mais lorsqu’une affectation est faite, le type est déterminé, c’est celui là et pas un autre, bordel. (Enfin… jusqu’à la prochaine affectation).

Ah oui ? mais alors, quel est donc le type de ce fameux None ? Ouvrons une console python et jouons un peu :

a = 5
type(a)

La console répond : <type ‘int’>
Le type de a est un numérique entier. Ces valeurs possibles sont : 0, 1, 2, -1, -2, … C’est super.

a = None
type(a)

La console répond : <type ‘NoneType’>
Le type de a est ‘NoneType’. Lorsqu’une variable est de ce type, sa seule valeur possible est ‘None’. Rigolo non ? Je crois même que c’est une espèce d’astuce pour se débarrasser d’un défaut de la théorie des types. La valeur vide est censée être de tous les types en même temps, et c’est un peu gênant. Bon enfin je dis ça, c’est juste pour faire mon malin parce que j’ai fait semblant de lire un article de Wikipédia que je me souviens même plus lequel c’est.

None = Nonne = gros nichons ?

None = Nonne = gros nichons ?

Tiens, pendant qu’on y est :

type(type(a))

ça répond : <type ‘type’>

type(type(type(a)))

ça répond aussi : <type ‘type’>
Les définitions de type : <type ‘int’>, <type ‘NoneType’>, etc. sont des valeurs, au même titre que 5, ou que None. Le type de ces valeurs est « type de valeur ».

« type de valeur » est également une définition de type, donc une valeur. Le type de la valeur « type de valeur » est « type de valeur ». Ha ha ! BOUCLE INFINIE OF THE DEATH !!!

Comme en Visual Beurk-hic, une comparaison avec None doit se faire sous la forme « machin is None », et non pas « machin == None ». La différence, c’est qu’en python on est un peu plus libre. Les deux fonctionnent.

Le == None est conventionnellement bizarre, et un peu dangereux dans des cas tordus. Parce qu’on peut surcharger l’opérateur « == », et donc créer une putain de classe qui renverrait True lorsqu’on la compare à None. Tandis que le « is » n’est pas surchargeable. C’est une comparaison d’identité brut, et non pas d’égalité de valeur. Et donc euh… Ben c’est mieux comme ça. (Interdit de dire que mes explications ne sont pas claires).

Et de toutes façons : « on n’est pas égal au vide. On EST le vide. »

Voici du blabla fun à ce sujet (http:// jaredgrubb.blogspot.com/2009/04/python-is-none-vs-none.html).

Ne rien faire, ça c’est la vie

Le vide peut s’exprimer par l’absence d’objet, mais aussi par l’absence d’action. On peut dire, explicitement : « Là, je ne fais rien ».

Comme j’ai envie de me coucher, on va faire court.

En langage machine, il existe l’instruction NOP (No Operation Performed). Selon les microprocesseurs, on peut avoir un code spécifique pour ça. En général 0, ou une valeur hexadécimale qui tombe juste. Dans le cas contraire, on a recours à une instruction normale, qu’on utilise avec des paramètres à la con, de façon que rien ne soit fait. Par exemple, le code 0x90, sur les processeurs x86, permet d’échanger le registre EAX avec le registre EAX. Whizzz !!

Tiens à propos de Whizzz, pour indiquer un NOP, on utilise parfois le mot-clé xyzzy. Mais là je ne saurais rien vous dire de plus que ce que j’irais pomper dans wikipedia. Donc allez-y direct.

Nothing happened...

Nothing happened…

Dans les langages de programmation de plus haut niveau, l’inaction peut également être exprimée, mais ce que je propose là est une vision des choses ‘  » ‘capillotractée’  » ‘.

  • Le point-virgule tout seul, dans les langages de bourgeois où les fins de lignes doivent comporter un point-virgule.
  • { }. C’est à dire un début de bloc de code, immédiatement suivi de la fin du bloc de code.
  • En Pascal, un « begin » immédatement suivi d’un « end ».

En python, on est beaucoup plus classe et plus explicite que cela, puisqu’il existe l’instruction pass, qui ne fait rien. Pourquoi en avoir besoin, alors que c’est un langage pas-machine ?

L’indentation a une signification en python. Or, on est obligé de mettre au moins une ligne de code, indentée, après un début de bloc « if », « while », ou autre. Si on ne veut rien y mettre, on doit explicitement mettre pass.

Le python est un putain de langage trop bien. Mais vous le saviez déjà.

piton

Piton

Conclusion :

Un jour, on m’a reproché de parler pour ne rien dire. Et je me suis dit que c’est surtout le reproche lui-même qui était du « parler pour ne rien dire ». Après, j’ai dit que je ne dirais plus rien à ces reprochateurs. Comme ça le problème a été réglé.

Je suis content de voir que vous avez lu jusque là ! D’ailleurs, peut-être avez-vous carrément lu jusqu’ici ? Ou là ? Bon, y’a qu’ à dire « là-bas ». Ça vous va ?

Le prochain article sera corporate et purgatif. Je baverais sur les anciennes boîte pour lesquelles j’ai bossé comme un con.

Programmer en C++, en alsacien

Buschur métame zé mézieurs !!

Auchaurtui, tans ce plog, kekeu choss d’apsolument inkroyap ! Nouss allons rékonzilier les tradizion réchionales afec le monte moterne, krasse à:

La

prokram-

mation

C++ en

elsassien

Pour commencer, je vais arrêter avec mon faux accent. C’est chiant à écrire, chiant à lire, et en plus je ne suis même pas originaire de cette belle région, (mais je la kiffe, na!).

alsacienne culotte

Y’a des gens, ils se sont fait chier pendant des années à apprendre les subtilités de cette langue alémano-teutonne, et tout ça pour quoi? Pour finalement découvrir que ça ne leur permettait absolument pas de créer des logiciels. C’est inadmissible. Voilà pourquoi j’ai décidé d’y remédier.

J’ai créé un fichier .h, qui redéfinit la vilaine syntaxe du C++ avec du bel alsacien bien de chez nous. Grâce à moi, du code abscons de ce genre:

int main(int argc, char *argv[])
{
int nombre_de_bieres = NOMBRE_DE_BIERE_AU_DEPART;
...
}

deviendra ceci:

numerik_surkrut des_esch_s_angfang_vom_program
s_brucht_sich numerik_surkrut de_zahl_von_parameter on_de_nor text_surkrut parameter des_esch_e_wandtafle so
esch_fong_e_wurst_on
esch_bruch_e numerik_surkrut het_ver_nome zahl_von_beer het_ver_vertigkeitsmaaser ZAHL_VON_BEER_OM_ANGFANG hopla
...
_s_gilt

Et là c’est mieux.

Par convention, et pour une immersion plus naturelle du truc dans le truc, j’ai décidé que les variables s’appelleraient « surkrut » (choucroute) et les blocs de code « wurst » (saucisse).

À noter que la transcription est assez permissive. La fin du programme peut se noter « esch_hop_s_wurst_vertig » (j’ai fini la saucisse), ou bien « _s_gilt » (à la vôtre !)

Ne parlant pas vraiment alsacien moi-même, c’est Geoffrey, l’un de mes nombreux amis de l’internet, qui m’a fait les traductions. Qu’il en soit infiniment remercié, puisse le chemin de sa vie être recouvert de choucroute garnie et qu’un millier de camions de femmes turpides dansent lascivement devant lui, avec un millier de milliers de bières.

RCLE020402_18_Mar02_08 topheavy

Image qu’a pas grand-chose à voir, mais on s’en fout.

Je vous mets le contenu du fichier directement ici. Il manque encore 2-3 trucs, mais soyez assurés que je créerai de nouvelles versions de plus en plus enrichies. (hahaha! nan.)

#define des_esch_s_angfang_vom_program main
#define hopla ;
#define sand <<
#define ens_surkrut_usgang cout
#define on_geh_e_schrett_vor << endl
#define geh_e_schrett_vor << endl
#define esch_vott_de_huffe_von using namespace
#define fundamant_denks std
#define numerik_surkrut int
#define text_surkrut char *
#define des_esch_e_wandtafle []
#define on_de_nor ,
#define s_brucht_sich (
#define so )
#define met (
#define e_fonktion_wie_di_ruckschekt
#define nex_von_allem void
#define on_wie_servert_on
#define esch_fong_e_wurst_on {
#define esch_hop_s_wurst_vertig }
#define _s_gilt }

choucroute pied
// Ceux qui programment avec leurs pieds ne seront pas déçus!

#define ken_surkrut
#define ken_surkrut_werd_gebrucht ()
#define esch_bruch_e
#define het_ver_nome
#define het_ver_vertigkeitsmaaser =
#define so_long_wie while (
#define ens_fall_wie if (
#define no )
#define s_meust_gemort_xen )
#define oder else
#define mor_d_nachst_wurst do
#define e_besele_weniger --
#define e_besele_meh ++
#define esch_meh_als >
#define esch_weniger_als <
#define oder_egal =
#define esch_egal_als ==
#define esch_verschid_als !=

Fabuleux! Mettons-ny-ous tout de suite!

Je vais pas me contenter de coder un stupide « Hello World », comme une petite feignasse de merde. Je vous ai carrément concocté un « 99 bottles of beer ». Pour les gens normaux qui connaissent pas, renseignez-vous ici (http:// 99-bottles-of-beer.net/).

Edit 11/10/2009

Le programme sort bien évidemment les paroles en alsacien, et pas en vilain-américain-capitaliste-violacé-d-argent. Sauf que j’avais fait la traduction à l’arrache et c’était du petit nègre sorti du cul d’une machine de Turing névropathe. Geoffrey-mon-ami-de-l-internet a rephrazingué tout ça et c’est mieux. (Puisse la choucroute le camion-gonzesse-bière etc.)

Télécharger la dernière version du programme (http:// sites.google.com/site/recherland/Home/alsace-power/elsass_power2.txt).

Vous pouvez le compiler sur l’ordinateur de votre grand-mère, ça marche et ça donne ceci:

99 Flashe beer uff d’Mura, 99 Flashe beer.
Drenk eins on geh widerch, 98 Flashe beer uff d’Mura.
Ken Flashe beer meh uff d’Mura, ken Flashe beer meh uff d’Mura.
Geh ens Gschaft on kauif der wedder meh, 99 Flashe beer uff d’Mura.

Par contre, le sens a un petit peu changé. La bière, au lieu de la « take one down and pass it around », on la « drenk on geh widerch » (bois-en une et continue). Mais ça reste tout à fait acceptable.

Digression: est-ce qu’on a encore le droit d’utiliser l’expression « petit nègre » pour indiquer qu’on parle avec plein de fautes? Je demande, parce que déjà, on n’a plus le droit de dire « tête de nègre », alors voilà quoi. Si j’ai offensé des gens, j’en suis désolé. (Bière, choucroute, camion, nichons.)

Lien vers un chouette dictionnaire françois-elsassien (http:// pagesperso-orange.fr/culture.alsace/dictionnaire_alsacien.htm).

À part ça, j’avais un oncle alsacien pure souche qui s’y connaissait vachement en langage et en histoire, mais il est mort. Dommage, il aurait pu m’aider.

medium allemande biere 2

Pas de jeu de mot avec « mise en bière », car elles sont si jolies.

Par ailleurs, comme je pige rien aux divers encodages de notre monde informatique torturé, j’ai pas mis les accents, trémas, et autres tuning de lettre tout bizarre. Avec ces stupides petits strüdels, on n’arrive jamais à ravoir ce que on a écrit au départ. Putain.

Village Dalzasse Pictures !!

Je ne suis pas le premier à avoir contribué au mariage entre l’Alsakie et le code informatique. Je ne serais qu’un fieffé paltoquet si je ne mentionnais pas ce splendide film qu’est Meytrix Reloatètt!!

Ça date un peu, mais moi j’adore et c’est de l’authentique. Allez voir le site originateur de la bande-annonce (http:// www. cigogne.net/Maytrix-reloatet-VA.html).

meytrix reloatett

Un film réalizé sans aukun trukaschh !!!

mélangeons nos cultures

Je ne suis pas le premier à avoir contribué au mariage entre l’Alsakie et l’Égypte mystérieuse et épicée. Je ne serais qu’un fieffé paltoquet si je ne saluais pas cette sympathique initiative de sculpture d’une superbe alsagyptienne aux yeux de chèvre morte.

alsagyptienne

Brrraaaiiiinnnssss !!!! (Traduction : Kougelhooooooof !!!)

La lala lalaaaaaaa

Pour finir, une petite chanson. C’est pas un truc pipi-caca de gamin de 10 ans. Non non. Cette fois-ci, c’est un peu plus adulte.

Je suis un alsacien,
je vais dans la forêt, avec mon gros fusil
chasser le papillon.
et le mammouth, dans la prairie,
qui broute broute broute, si joyeusement
et les saucisses, dans la boucherie,
qui pendent pendent pendent, si joliment.

‘s gilt!

Edit 11/10/2009

Durant mes recherches documentaires sur le l’intraweb, je suis tombé (complètement par hasard) sur cette sympathique photo. Je vous en fais cadeau.

chloe vevrier beer fest

Edit 11/10/2009

Edit(h Cresson)

OFRTP-UNION-FRANCE-CRESSON-20060711 Edith Cresson

invisible hamburger !

Edith 11/10/2009

botte cresson