Découvrir Python avec un livre dont vous êtes le héros numérique

Texte intégral

(1)

Bienvenue sur l'espace de ressources et tutoriels des Conseillers Numériques de la Labomedia !

Vous pouvez également nous retrouver dans le monde non-numérique, les mercredis de 13H à 19H, au 108 rue de Bourgogne.

Pour télécharger la démo, c'est ici ! Présentation

Je vous propose dans ce tutoriel de découvrir les bases de la programmation en Python via le premier algorithme que j’ai moi-même codé tout seul : un ‘livre dont vous êtes le héros’

numérique.

Le principe de ces livres est de vous embarquer dans une grande aventure qui, à chaque page, vous proposera plusieurs possibilités pour faire avancer le récit, chacune vous renvoyant vers une page spécifique. À vous de découvrir le bon chemin pour atteindre le bout de l’aventure, en sauvant la princesse… ou en passant de vie à trépas.

Mais chaque chose en son temps !

En réalité, nous commencerons par une présentation des outils de base de programmation en Python, puis nous passerons à une présentation plus générale du concept de programme .

Le Python

Commençons par découvrir Python. Il s’agit d’un langage de programmation, né en 1989, qui en est actuellement à sa 3ème version. Si vous êtes friand d’histoire, n’hésitez pas à consulter

la

Découvrir Python avec un

‘livre dont vous êtes le

héros’ numérique

(2)

page wikipédia de Python

. Python est un langage qui est beaucoup utilisé dans le milieu scientifique, car il permet de résoudre des problèmes complexes sans avoir à apprendre les codes de la programmation, en tout cas pas de manière approfondie.

Dans certains langages, il est par exemple nécessaire d’inclure un ‘ ; ‘ à la fin des instructions.

Python retire cette nécessité, ainsi qu’un certains nombre de tâches rébarbatives liées aux principes informatiques. Dans les fait, il perd en flexibilité et en rapidité de calcul, mais ça n’est pas quelque chose qui nous concerne.

Un des intérêts principaux de Python est la grande panoplie de librairies qu’il possède, qui sont des petits bouts de codes prêts à l’emploi que vous pouvez utiliser pour résoudre un problème particulier. Par exemple, la librairie librosa est dédiée à la manipulation de fichier audio, pygame permet de créer des jeux vidéos.

Du fait de sa proximité avec le monde scientifique, Python est un des langages les plus utilisés dans la programmation d’intelligences artificielles.

Premier Pas : Bonjour Monde

Une tradition, tardive, du monde informatique, est de commencer la découverte d’un langage par un programme tout simple, nommé ‘Hello World‘, qui sert à vérifier que l’installation du langage a fonctionné et que nous sommes parés à commencer.

Pour installer Python, vous pouvez

le télécharger depuis le site officiel

. Sur

Linux, à la place, on utilisera généralement la ligne de commande suivante :

Une fois le logiciel installé, assez bizarrement, nous pouvons commencer à écrire du code…

dans n’importe quel éditeur de texte !

En effet, un fichier contenant du code n’est rien d’autre qu’un fichier texte, comme vous pourriez écrire une liste de course ou un poème en vers. Seule change l’extension, qui permet d’indiquer à l’ordinateur quel type de code il contient. L’extension associée à Python est .py, nous allons donc créer un fichier nommé hello_world.py, préférablement dans un dossier nommé Python, pour ne pas s’éparpiller. Dans ce fichier, nous écrirons une simple ligne de code :

Et pour l’instant, c’est tout ! Voyons maintenant comment nous pouvons exécuter ce fichier.

En premier lieu, nous allons voir la méthode à l’ancienne.

sudo apt-get install python

print( "Hello World" )

(3)

À l’ancienne, nous utilisons le terminal, ou sous windows l’invite de commande, pour ce faire. Deux méthodes sont envisageables :

Pour l’exécuter depuis n’importe où. En général, on se rend plutôt dans le dossier, puis on l’exécute :

Pas besoin de retaper les commandes à chaque fois : le terminal se souvient des dernières commandes, et vous pouvez y accéder avec la flèche du haut.

Le résultat du programme apparaît à l’écran ! Vous avez affiché ‘Hello World‘ à l’écran ! C’est votre premier pas dans la matrice !

De manière plus moderne, nous utilisons généralement un IDE, c’est-à-dire un logiciel de traitement de texte adapté pour programmer. Outre des fonctionnalités avancées, il suffit en général d’appuyer sur une touche (F5, par exemple), pour lancer le programme, ce qui permet de gagner du temps. Parmi les IDE disponibles : Geany, Sublime Text, Thony…

Maintenant que vous savez faire, prenez bonne note : à chaque exemple de code que vous trouverez dans ce tutoriel, vous êtes encouragé à le copier-coller pour le tester, le modifier, l’analyser. Soyez patient.

Le matériau de base : La variable

Nous venons de voir comment afficher quelque chose dans le terminal. Ne croyez pas qu’il s’agisse de quelque chose de trivial. Si vous poursuivez le développement, c’est peut-être l’outil que vous utiliserez le plus souvent, notamment pour vous renseigner sur les erreurs qui font planter le programme.

Imaginons maintenant que, pour une raison quelconque, vous souhaitiez afficher trois fois de suite la même information à l’écran. En partant de l’exemple précédent, le code à l’intérieur du fichier ressemblerait à cela :

Cela fonctionne sans souci. Mais supposons maintenant que vous souhaitiez changer le texte à afficher, par exemple par ‘Bonjour Monde‘. Il vous faudrait alors changer à chaque ligne le texte entre parenthèse, ce qui est rébarbatif, et, osons le mot, tout-à-fait inadmettable.

python /chemin/vers/mon/fichier.py

cd /chemin/vers/mon/dossier/

python hello_world.py

print( "Hello World" ) print( "Hello World" ) print( "Hello World" )

(4)

À la place, nous allons nous servir d’un outil omniprésent dans le monde de l’informatique : la variable. L’idée est la suivante :

La première ligne de ce code constitue ce que l’on appelle une déclaration de variable.

Autrement dit, à la création d’une variable. Une variable est constituée de trois élément : son nom, son contenu, et son type. Python est pensé pour que la question du type soit transparente pour l’utilisateur, nous laisserons provisoirement cette notion de côté. Ce qui nous intéresse en tant que programmateur, c’est le contenu de la variable, ici les mots ‘ Bonjour Monde‘. Le nom de la variable, ma_variable, permet de faire référence au contenu de la variable.

Dans l’exemple précédent, quand on demande d’afficher la variable en utilisant son nom, c’est son contenu qui est affiché dans le terminal. Il est donc maintenant possible de

modifier uniquement le contenu de la variable, à la première ligne, pour modifier les trois éléments affichés dans le terminal.

Il est possible de changer le contenu d’une variable au cours du programme :

Sans rentrer dans les détails pour l’instant, un exemple un peu plus complexe :

Le Couteau Suisse : La fonction

Voyons maintenant un deuxième outil de programmation important : la fonction. La fonction, de la même manière que la variable, permet d’associer un nom à un bout de code.

Considérez le code qui suit : ma_variable = "Bonjour Monde"

print( ma_variable ) print( ma_variable ) print( ma_variable )

ma_super_variable = "Hello World"

print( ma_super_variable )

ma_super_variable = "Bonjour Monde"

print( ma_super_variable )

mon_compteur = 0

while mon_compteur < 101:

print( mon_compteur )

mon_compteur = mon_compteur + 1

(5)

Ce code est scindé en deux parties distinctes : d’abord la fonction est créée, puis, deux fois, elle est utilisée.

Pour créer une fonction, on utilise la forme suivante :

D’abord, il faut indiquer à Python que l’on va créer une fonction avec le mot-clef ‘def‘. Il faut ensuite lui assigner un nom, puis, entre parenthèses, les arguments, qui viendront modifier le comportement de la fonction. Il peut ne pas y en avoir, ou y en avoir un nombre quelconque ( voir les exemples ci-dessous ). On finit ensuite par ‘ : ‘ .

Les lignes suivantes contiennent le code qui constituent la fonction. Afin d’indiquer à Python quelles lignes font partie de la fonction, on utilise un mécanisme appelé l’indentation.

Ci-dessus, ces indentations sont indiquées par le signe >, que j’ai ajouté pour que l’indentation soit visible. Attention, il ne faut pas utiliser > dans votre code ! À la place, vous décalez le code vers la droite, à l’aide de la touche tabulation.

Si vous reprenez l’exemple ci-dessus, vous pouvez voir que les lignes

sont indentées, car elles font partie de la fonction, alors que les lignes

ne le sont pas car elles n’en font pas partie.

Un exemple sans argument : def mettre_au_carre( nombre ):

le_carre_du_nombre = nombre * nombre print( le_carre_du_nombre )

mettre_au_carre( 5 ) mettre_au_carre( 17 )

def nom_de_la_fonction( argument(s) ):

> code

> code

le_carre_du_nombre = nombre * nombre print( le_carre_du_nombre )

mettre_au_carre( 5 ) mettre_au_carre( 17 )

def print_hello_world():

print( "Hello World" )

(6)

Un exemple avec deux arguments :

Utilisateur, erreur et type

Voyons maintenant une fonction utile intégrée à Python : input(). Elle permet à l’utilisateur de rentrer du texte, via le clavier, dans le programme :

Bien. Adaptons cette idée à notre fonction mettre_au_carre() afin de proposer un

programme interactif qui permette à l’utilisateur de mettre au carré le nombre qu’il tape dans le terminal. Pour rappel, n’hésitez pas à prendre votre temps pour comprendre comment le code est construit avant de le tester :

Avez-vous essayé ? Que se passe-t’il ?

J’ai essayé avec 5… Le résultat n’était pas très concluant ! Voici ce que le terminal m’a répondu : print_hello_world()

def multiplier( nombre1, nombre2 ):

produit = nombre1 * nombre2 print( produit )

multiplier( 5, 17 )

print( "Quel est votre nom ?" ) nom_utilisateur = input()

print( "Enchanté, " + nom_utilisateur )

def mettre_au_carre( nombre ):

le_carre_du_nombre = nombre * nombre print( le_carre_du_nombre )

print( "Quel nombre souhaitez-vous élever au carré ?" ) nombre_a_mettre_au_carre = input()

mettre_au_carre( nombre_a_mettre_au_carre )

Traceback (most recent call last):

File "carre.py", line 8, in <module>

mettre_au_carre( nombre_a_mettre_au_carre ) File "carre.py", line 3, in mettre_au_carre

(7)

Malheureusement, les ordinateurs n’ont pas encore intégré la politesse… Il s’agit d’un message d’erreur. En général, les premières lignes nous indiquent où se situe l’erreur, et la

dernière nous explique pourquoi ça coince :

Ici, Python est mécontent pour une raison d’apparence simple mais en fait assez subtile. En français courant, il se plaint en fait d’être incapable de multiplier un mot. Pour

comprendre cela, il faut revenir à la notion de type de variable que nous avons écartée plus tôt.

Dans la manière dont il fonctionne, un ordinateur ne sait pas vraiment ce qu’est un nombre.

De son point de vue, il ne voit défiler que des suites de 0 et de 1. Pour un peu mieux différencier ces informations, il a été programmé pour interpréter les variables selon des grandes catégories. Les plus simples sont les suivantes :

integer : qui sont des nombres entiers float : qui sont des nombres à virgules string : qui contiennent du texte

boolean : qui sont soit vraies, soit fausses

Dans notre cas, la fonction input() prend uniquement du texte en entrée, c’est-à-dire une information de type string. Nous pourrions taper n’importe quel mot dans le terminal, par exemple ‘pomme’, ‘cinq’, ou encore ‘5’. Dans le dernier cas, l’ordinateur continue de traiter cette information comme un mot, et non un nombre, là où un humain saurait directement reconnaître un nombre. Ainsi, dans le cas actuel, quand nous lui demandons de multiplier ‘5’ par

‘5’, c’est pour lui comme si nous lui demandions de multiplier ‘pomme’ par ‘pomme’. Ce qui lui déplaît.

Pour ce faire, il faut convertir le mot en entrée en nombre entier, à l’aide de la fonction int() :

Grâce à cette conversion, j’obtiens bien 25 en entrant 5 dans le programme ! le_carre_du_nombre = nombre * nombre

TypeError: can't multiply sequence by non-int of type 'str'

TypeError: can't multiply sequence by non-int of type 'str'

def mettre_au_carre( nombre ):

le_carre_du_nombre = nombre * nombre print( le_carre_du_nombre )

print( "Quel nombre souhaitez-vous élever au carré ?" ) nombre_a_mettre_au_carre = input()

nombre_a_mettre_au_carre = int( nombre_a_mettre_au_carre ) mettre_au_carre( nombre_a_mettre_au_carre )

(8)

Vrai ou Faux : Avec des si, on mettrait Python en bouteille ?

Mais je vous vois venir ! Que se passe-t’il si l’on demande maintenant de mettre ‘pomme’

au carré ?

Ben oui, ça plante…

int() ne fonctionne que si le mot que vous voulez convertir correspond effectivement à un nombre entier. Le cas échéant…

Une bonne partie du travail de développeur consiste à prévenir ce genre d’erreur, qui ne font pas sens dans l’absolu mais sont effectivement possibles.

Voici une solution à ce problème qui nous permettra d’introduire un troisième outil, la condition if :

Ici, nous demandons à l’ordinateur de mettre le nombre au carré, après conversion, si et seulement si le mot donné correspond effectivement à un nombre entier.

Incisons un peu le code :

Ici, nous utilisons une fonction un peu spéciale, isnumeric(), qu’il n’est possible d’utiliser qu’avec une variable de type string, donc contenant du texte. Utilisée comme cela, elle équivaudra à la réponse à la question « Est-ce que ce texte est l’équivalent d’un nombre ? ».

Par exemple, ‘5’.isnumeric() équivaut à « vrai » ( en Python : True ), ‘pomme’.isnumeric() équivaut à « faux » ( en Python : False ).

C’est un type de variable que l’on appelle booléenne ( Boolean ), qui ne peut contenir que deux informations distinctes : soit True, soit False.

def mettre_au_carre( nombre ):

le_carre_du_nombre = nombre * nombre print( le_carre_du_nombre )

print( "Quel nombre souhaitez-vous élever au carré ?" ) nombre_a_mettre_au_carre = input()

if nombre_a_mettre_au_carre.isnumeric():

nombre_a_mettre_au_carre = int( nombre_a_mettre_au_carre ) mettre_au_carre( nombre_a_mettre_au_carre )

nombre_a_mettre_au_carre.isnumeric()

(9)

Elle est particulièrement utile au sein d’un programme en conjonction avec un outil nommé ‘ conditionnel‘, dont je vous présenterai ici le plus simple : if .

if permet d’exécuter le code indenté des lignes suivantes si et seulement si la condition qui le suit est vraie. Reprenons notre exemple précédent :

Ici, les deux lignes indentées ne seront exécutés que si le contenu de la variable

nombre_a_mettre_au_carre correspond à un nombre entier. Le cas échéant, les lignes seront ignorées.

Pour aller plus loin, vous pouvez utiliser le mot else pour spécifier ce qu’il doit se passer au cas où la condition n’est pas respectée, mais ce n’est pas obligatoire :

Vous remarquerez que ce code n’est pas optimal, parce qu’il ne permet pas d’élever au carré des nombres à virgule, mais ce n’est pas très grave.

Comment taire ?

Une petite note rapide sur la ligne suivante, que vous pourriez trouver dans un code en Python :

Le symbole # permet d’indiquer à Python d’ignorer cette ligne lors de l’exécution. Il s’agit de permettre au développeur d’écrire du texte humain, pour les humains, et d’indiquer, par

if nombre_a_mettre_au_carre.isnumeric():

nombre_a_mettre_au_carre = int( nombre_a_mettre_au_carre ) mettre_au_carre( nombre_a_mettre_au_carre )

def mettre_au_carre( nombre ):

le_carre_du_nombre = nombre * nombre print( le_carre_du_nombre )

print( "Quel nombre souhaitez-vous élever au carré ?" ) nombre_a_mettre_au_carre = input()

if nombre_a_mettre_au_carre.isnumeric():

nombre_a_mettre_au_carre = int( nombre_a_mettre_au_carre ) mettre_au_carre( nombre_a_mettre_au_carre )

else:

print( "Arrêtez de jouer l'andouille, nom d'une pipe !" )

# Je suis un commentaire !

(10)

exemple, l’utilité d’une ligne ou un problème qu’il rencontre. On appelle ce type de ligne un commentaire.

Et ce livre, alors ?

Nous y arrivons. Un petit mot avant cela. Vous venez de découvrir, rapidement, les bases de la programmation en Python. Il était difficile d’aborder la suite sans ces prérequis.

À ce stade, je vous conseillerai d’essayer d’écrire quelques programmes de votre invention en expérimentant avec les connaissances présentées ci-dessus.

Également, vous pouvez jeter un coup d’œil sur

des tutoriels et exercices en

lignes, ainsi que sur la documentation du langage

. Si vous persévérez, vous y passerez très certainement un petit bout de temps…

Le livre donc

Je vous propose donc de découvrir un algorithme qui permet de créer un ‘livre dont vous êtes le héros’ numérique.

Dans la partie précédente, la méthode que nous suivions était la suivante : nous présentons une fonctionnalité de Python, puis nous cherchons à comprendre ce qu’elle permet.

Ici, c’est l’inverse : nous souhaitons créer une fonctionnalité, puis nous nous demandons quels sont les outils à utiliser.

C’est le premier pas de l’étape de développement : se demander si créer l’outil auquel on pense est possible. Ici, nous voudrions afficher une histoire dans le terminal, puis proposer à l’utilisateur plusieurs choix afin qu’il puisse décider de la direction que prend son aventure. Ce qui devrait ressembler à cela :

Assez intuitivement, nous savons qu’il est possible d’utiliser print() pour afficher du texte à l’écran, input() pour demander à l’utilisateur d’interagir, et if pour permettre le choix

Vous vous réveillez par un beau matin.

Après quelques étirements et un copieux petit déjeuner, vous arrivez dans votre salon.

Que faîtes-vous ? [0] Sortir dans la rue

[1] Aller dans la bibliothèque

(11)

entre différentes possibilités. Nous sentons que l’algorithme est donc possible.

Si nous avions voulu que l’ordinateur, à la place, écrive le livre à l’aide d’un crayon, puis le relie, là par contre, ça n’était pas possible. En fait, si, c’était possible, mais à condition de construire un méga-robot super complexe. Vous avez compris l’idée.

À quoi ressemble le livre ?

Plutôt que de vous décrire le code ligne à ligne, je vous propose de regarder le schéma suivant comme point de départ à l’algorithme :

Il s’agit d’un diagramme qui présente les pages du jeu que j’ai fait, ainsi que leurs connections.

En bleu, la page ‘entrée‘ est le point de départ. En gris, ce sont les ‘chemins‘, qui

permettent de naviguer de page en page. En rose, ce sont les ‘impasses‘, qui terminent le jeu, de manière plus ou moins heureuse, et renvoient au début du jeu, c’est-à-dire la page ‘entrée

‘.

Les flèches, quand à elles, indiquent comment communiquent les pages entre elles. Depuis l’ ‘entrée‘, par exemple, on peut aller soit dans la ‘bibliothèque‘, soit dans la ‘rue‘. Il n’est par contre pas possible de revenir à l’ ‘entrée‘. Depuis le ‘livre‘, on ne peut que repartir vers la ‘ bibliothèque‘.

Si vous souhaitez créer votre propre jeu, je vous conseille de faire un schéma similaire, qui vous permet de voir si les pages s’agencent bien entre elles, et s’il est possible d’accéder à toutes les pages.

(12)

À quoi ressemble une page ?

Nous venons de comprendre ce qu’était le livre : une espèce de réseau de pages qui sont reliées entre elles.

Mais qu’est-ce qu’une page ?

Dans la version simple que je vous propose, il suffit de trois éléments pour constituer une page :

Tout d’abord, l’histoire de la page. C’est le texte qui

s’affiche dans le terminal quand on arrive à la page, et qui donne le ton concernant le choix d’utilisateur.

Ensuite, les choix disponibles à l’utilisateur. Pour chacun d’eux, deux éléments sont importants : la description du choix, ainsi que la page vers laquelle il mène.

Enfin, bien que l’utilisateur n’en saura rien, nous avons besoin que Python différencie les pages ‘chemin‘, qui contiennent des ‘choix‘, et les pages ‘impasse‘, qui n’en contiennent pas, et renvoient nécessairement au début du jeu.

Reprenons l’exemple précédent :

En italique, vous pouvez voir l’histoire de la page. En gras, ce sont les choix disponibles. Le type de page n’est pas affiché tel quel, mais puisqu’il est possible de faire un choix, il s’agit d’un ‘ chemin‘.

Vous vous réveillez par un beau matin.

Après quelques étirements et un copieux petit déjeuner, vous arrivez dans votre salon.

Que faîtes-vous ? [0] Sortir dans la rue

[1] Aller dans la bibliothèque

(13)

Comment traduire cela en Python ? Eh bien j’ai pour cela utilisé un dictionnaire. Un

dictionnaire permet de stocker, à l’intérieur d’une variable unique, un grand nombre de sous-variables accessibles via un mot-clef. Voici un exemple :

Comme vous pouvez le voir, il est possible de représenter des objets complexes de cette manière.

Dans notre cas, voici le fichier que j’ai créé pour la page ‘entrée‘, vous pouvez le copier- coller dans un fichier pour plus de lisibilité :

Il ne s’agit même pas d’un fichier Python : il s’appelle entree.txt, et je l’ai rangé dans un sous-dossier ‘pages‘.

Comme indiqué précédemment, je créé un dictionnaire contenant trois entrées : ‘type‘, ‘ histoire‘ et ‘choix‘.

‘type‘ ne peut prendre que deux valeurs : ‘chemin‘ et ‘impasse

‘.

‘histoire‘ contient une string qui correspond tout simplement à l’histoire que vous racontez à la page actuelle.

L’entrée ‘choix‘ est un poil plus complexe. Elle contient elle- même un dictionnaire par choix, qui sont contenus entre

personne = { "nom": "Durand", "prenom": "Bernard", "age": 37,

"taille": 1.74 }

print( personne["prenom"] )

{

"type": "chemin",

"histoire": "Vous vous réveillez par un beau matin.\nAprès quelques étirements et un copieux petit déjeuner, vous arrivez dans votre salon.",

"choix": [

{ "proposition": "Sortir dans la rue", "vers_la_page": "rue.txt" },

{ "proposition": "Aller dans la bibliothèque", "vers_la_page": "bibliotheque.txt" } ]

}

(14)

crochets. Vous pouvez rajouter autant de dictionnaires, c’est-à- dire de choix, que vous souhaitez, en les séparant par des

virgules.

Chaque dictionnaire de choix est lui-même constitué de deux paramètres : une entrée ‘ proposition‘, qui indique la phrase à afficher dans le terminal pour ce choix, et une entrée ‘ vers_la_page‘, qui référence le nom du fichier à charger quand l’utilisateur fait ce choix-là.

De fait, pour rajouter un choix à l’utilisateur, vous pourrez par exemple rajouter cette entrée dans le fichier, avant le crochet fermant, et en ayant ajouté une virgule après le dictionnaire de choix précédent :

Il vous faudra ensuite, bien sûr, rédiger la page correspondante.

Pour une ‘impasse‘, c’est le même principe, mais nous indiquons

et supprimons l’entrée ‘choix‘, car il n’y en a pas.

Par exemple, le fichier ‘chute.txt‘ :

Note : vous avez pu voir ‘\n‘ se balader dans les textes ci-dessus. Il s’agit d’un symbole spécial pour demander à Python de sauter une ligne à ce moment là.

Le Code

En fait, vous avez déjà tous les outils pour créer vous-même le livre. Le code Python que j’ai créé vous permet d’écrire les fichiers textes des pages sans même avoir à vous embêter avec ce qu’il contient.

Tant que vous suivez les règles précédentes de création de page, et que vous nommez votre première page ‘entree.txt‘, alors le programme s’occupe tout seul d’assembler le livre pour vous.

{ "proposition": "Aller à la cave", "vers_la_page": "cave.txt" }

"type": "chemin",

{

"type": "impasse",

"histoire": "Vous faîtes un premier pas vers l'abîme qui s'ouvre devant

vous.\nMalheureusement, les années ont érodé la pierre et l'on rendue glissante.\nLa chute est brutale, et vous ne vous en releverez pas...\n\nGAME OVER"

}

(15)

Mais jetons quand même un coup d’œil ! Il ressemble à ceci :

import os import json

def lire_la_page( page ):

os.system( 'cls' if os.name == 'nt' else 'clear' )

print( page["histoire"] )

if page["type"] == "chemin":

print( "\n" )

print( "Que faîtes-vous ?" )

for i in range( len( page["choix"] ) ):

texte = "[" + str( i ) + "] "

texte = texte + page["choix"][i]["proposition"]

print( texte )

decision = input()

la_decision_est_valide = False if decision.isnumeric():

if int( decision ) >= 0:

if int( decision ) <= len( page["choix"] ):

la_decision_est_valide = True

if not la_decision_est_valide:

lire_la_page( page )

if la_decision_est_valide:

charger_la_page( page["choix"][int( decision )]["vers_la_page"] )

elif page["type"] == "impasse":

decision = input()

charger_la_page( "entree.txt" )

def charger_la_page( nom_du_fichier ):

(16)

C’est un peu velu, mais il est long surtout parce que j’ai espacé les lignes. Si vous regardez bien, la majorité du code est en fait contenu dans deux fonctions distinctes : lire_la_page() et charger_la_page(). Commençons par oublier leur contenu un instant, et regardons le code :

C’est déjà bien plus clair ! Il s’agit là d’une vue d’ensemble de l’algorithme. En fait, cela nous permet de faire le lien avec le schéma suivant :

 

Ce schéma, est d’une certaine manière, le travail le plus important du développeur. Il s’agit de se représenter le problème à résoudre, ici la création d’un ‘livre dont vous êtes le héros‘, comme une suite d’étapes successives, sans rentrer dans le détail.

Une fois que cette vue d’ensemble est posée, il ne reste plus qu’à mettre en place les sous- étapes, et les relier entre elles.

Dans notre cas, nous lançons le programme, puis nous répétons indéfiniment la suite ‘ charger la page‘ > ‘afficher la page‘ > ‘choix‘.

with open( "pages/" + nom_du_fichier,'r',encoding = 'utf-8') as mon_fichier:

page_actuelle = json.load( mon_fichier ) mon_fichier.close()

lire_la_page( page_actuelle )

charger_la_page( "entree.txt" )

import os import json

def lire_la_page()

def charger_la_page()

charger_la_page( "entree.txt" )

(17)

Étape 1 : lancement du programme

De manière générale, la première partie d’un programme consiste à mettre en place les éléments dont le programme a besoin pour fonctionner. C’est notamment là que l’on déclare les variables, même si vous pouvez remarquer que mon programme n’en utilise pas de manière globale.

Les deux premières lignes que j’utilise permettent à Python de charger des librairies spéciales dont j’aurai besoin plus tard. Ces lignes ont donc été rajoutées pendant que j’écrivais les fonctions qui les utilisent, mais l’importation doit se faire en tout début de programme.

Ensuite, je créé (déclare) mes fonctions pour pouvoir les utiliser plus tard.

Enfin, je lance ma boucle en utilisant la fonction charger_la_page() pour ouvrir ma première page. Les fonctions doivent avoir été déclarées avant d’êtres utilisées.

Étape 2 : charger une page

Nous venons donc d’appeler la fonction charger_une_page() avec l’argument ‘entree.txt‘, qui correspond à notre première page. Voici le code de la fonction, dont j’ai réduit la première indentation pour plus de lisibilité :

Je ne rentrerai pas spécialement dans le détail de certaines fonctionnalités, vous pouvez vous référer à la documentation en cas de besoin.

La première ligne me permet d’ouvrir le fichier dont le nom est passé en argument, et qui devra se trouver dans un dossier nommé ‘pages‘. Il est ouvert en lecture seule, et stocké dans une variable nommé mon_fichier.

import os import json

def lire_la_page() def charger_la_page()

charger_la_page( "entree.txt" )

def charger_la_page( nom_du_fichier ):

with open( "pages/" + nom_du_fichier,'r',encoding = 'utf-8') as mon_fichier:

page_actuelle = json.load( mon_fichier ) mon_fichier.close()

lire_la_page( page_actuelle )

(18)

La deuxième ligne transforme le contenu de la variable, qui est encore une string, en dictionnaire, et le stocke dans une variable nommé page_actuelle.

La troisième ligne ferme le fichier.

Enfin, la quatrième ligne appelle la fonction afficher_la_page(), avec comme argument le dictionnaire contenant les informations de la page à lire.

Étape 3 : la page

Voyons maintenant la fonction lire_la_page() :

def lire_la_page( page ):

os.system( 'cls' if os.name == 'nt' else 'clear' )

print( page["histoire"] )

if page["type"] == "chemin":

print( "\n" )

print( "Que faîtes-vous ?" )

for i in range( len( page["choix"] ) ):

texte = "[" + str( i ) + "] "

texte = texte + page["choix"][i]["proposition"]

print( texte )

decision = input()

la_decision_est_valide = False if decision.isnumeric():

if int( decision ) >= 0:

if int( decision ) <= len( page["choix"] ):

la_decision_est_valide = True

if not la_decision_est_valide:

lire_la_page( page )

if la_decision_est_valide:

charger_la_page( page["choix"][int( decision )]["vers_la_page"] )

(19)

C’est le cœur de l’algorithme que nous voyons ici. En termes humains, il s’agit d’un décodeur de fichier ‘page‘. Il doit donc pouvoir manipuler un dictionnaire, qu’il corresponde à un ‘chemin‘ ou une ‘impasse‘.

Encore une fois, nous allons réduire le code pour gagner en lisibilité :

Comme vous pouvez le voir, en bas, nous utilisons if, et sa contrepartie elif, pour distinguer ce qu’il y a à faire si la page est un ‘chemin‘ ou une ‘impasse‘. C’est justement pour cela que nous avons créé l’entrée ‘type‘.

Les deux premières lignes sont à exécuter dans les deux cas :

La première permet juste d’effacer l’affichage actuel du terminal, afin de faire place net.

La seconde affiche l’histoire à l’écran.

Étape 3 : l’ ‘impasse‘

Commençons par voir ce qui se passe dans le cas d’une ‘impasse‘, qui est le plus simple :

Dans un premier temps, nous demandons simplement un input() pour attendre que l’utilisateur valide avec la touche ‘Entrée’.

Puis, nous rechargeons la première page. Et la boucle est bouclée ! elif page["type"] == "impasse":

decision = input()

charger_la_page( "entree.txt" )

os.system( 'cls' if os.name == 'nt' else 'clear' ) print( page["histoire"] )

if page["type"] == "chemin":

choses à faire pour un chemin

elif page["type"] == "impasse":

choses à faire pour une impasse

decision = input()

charger_la_page( "entree.txt" )

(20)

Étape 3 : le ‘chemin‘

Que se passe-t’il dans le cas d’un ‘chemin‘ ?

Encore une fois, saucissonnons les étapes.

En premier, nous sautons une ligne pour des questions de lisibilité, puis nous questionnons l’utilisateur :

Ensuite, pour chacun des choix disponibles, nous affichons à l’écran le numéro du choix ainsi que son intitulé :

print( "\n" )

print( "Que faîtes-vous ?" )

for i in range( len( page["choix"] ) ):

texte = "[" + str( i ) + "] "

texte = texte + page["choix"][i]["proposition"]

print( texte )

decision = input()

la_decision_est_valide = False if decision.isnumeric():

if int( decision ) >= 0:

if int( decision ) <= len( page["choix"] ):

la_decision_est_valide = True

if not la_decision_est_valide:

lire_la_page( page )

if la_decision_est_valide:

charger_la_page( page["choix"][int( decision )]["vers_la_page"] )

print( "\n" )

print( "Que faîtes-vous ?" )

for i in range( len( page["choix"] ) ):

texte = "[" + str( i ) + "] "

texte = texte + page["choix"][i]["proposition"]

print( texte )

(21)

À ce stade, nous attendons que l’utilisateur entre son choix :

Ensuite, en fonction de ce que nous indique l’utilisateur, deux choses sont possibles : soit celui-ci à entré une mauvaise information, comme ‘pomme‘, ou un nombre qui dépasse la question. Dans ce cas-là, nous tombons dans le déni et réaffichons la page.

Le cas échéant, nous allons appeler la fonction charger_la_page() avec la page demandée.

Et la boucle est bouclée !

Goodbye World

Et voilà, pas besoin d’aller plus loin, la boucle est bouclée dans tous les cas, et elle s’adapte à votre nombre de page sans difficulté. C’est donc l’heure d’appeler à vos imaginations

débordantes pour proposer 1 001 histoires !

Pfiou ! C’était un peu long pour une initiation, mais l’essentiel y est ! Vous avez tous les outils pour concevoir un projet et le mettre en œuvre, et en petit plus, la possibilité d’écrire un jeu vidéo narratif !

Sans plus m’étendre, je vous remercie pour la la lecture, et à bientôt ! decision = input()

Révision #8

Créé 4 November 2021 13:08:04 par Simon Mis à jour 8 February 2022 13:24:25 par Simon

Figure

Updating...

Sujets connexes :