Éviter les répétitions : les choses importantes

Rappelez-vous de la règle à propos d'éviter les répétitions :

Règle N°3

Quand vous écrivez des programmes, ne vous répétez pas.
Je répète : ne vous répétez pas !

Ce que nous allons voir dans ce chapitre est un moyen d'éviter de "réinventer la roue".

1. Rappel : trois gauches peuvent faire une droite

Souvenez-vous quand nous avons introduit l'instruction turn_right() :

def turn_right():
    turn_left()
    turn_left()
    turn_left()

Nous avons fait cela pour éviter d'avoir à taper turn_left() trois fois de suite à chaque fois que nous voulions commander à Reeborg de tourner à droite. Cependant, nous avons toujours beaucoup de répétitions puisque presque à chaque fois que nous écrivons un nouveau programme, nous nous mettons à définir turn_right() encore une fois. Il y a toutefois un moyen d'éviter cela. Créez le programme suivant et essayez de l'exécuter.

from useful import turn_right

turn_right()
turn_off()

2. À propos de useful

J'ai créé pour vous un faux module nommé "useful" contenant quelques instructions nouvellement definies. Au lieu d'expliquer ce que chaque nouvelle instruction fait, voici un programme exemple avec la capture d'écran correspondante.

from useful import *

turn_left()
move()
set_trace_style(1, 'red')
turn_right()
set_trace_style(2, 'blue')
move()
set_trace_style(1, 'green')
climb_up_east()
set_trace_style(2, 'blue')
move()
set_trace_style(1, 'orange')
turn_around()
set_trace_style(2, 'sea green')
climb_up_west()
set_trace_style(1, 'red')
turn_around()
set_trace_style(0, 'blue') # 0 = invisible
repeat(move, 4)
set_trace_style(1, 'green')
climb_down_east()
set_trace_style(2, 'blue')
move()
set_trace_style(1, 'black')
turn_around()
set_trace_style(2, 'red')
climb_down_west()
turn_off()

Au lieu d'importer chaque nouvelle instruction une à une, comme nous l'avons fait dans le premier exemple avec turn_right(), nous avons utilisé la notation "*" pour indiquer "toutes les définitions". Avant de continuer, je devrais peut-être faire quelques commentaires :

1. Pour ceux qui connaissent les modules Python, "useful" n'est pas un vrai module, mais un faux qui ne fonctionnera que dans le monde de Reeborg. Vous ne serez autorisé à importer aucun module "réel" pour l'utiliser dans des programmes RUR. Cela a été fait pour des raisons de sécurité.
2. Une nouvelle instruction, set_trace_style() a été utilisée [régler le style de trace]. J'aurais pu l'appeler
   set_leaking_oil_colour_and_quantity() [régler la couleur de l'huile de fuite et sa quantité], ce qui aurait plus de sens dans le monde de Reeborg... mais pas dans le jargon de la programmation en général. En gros, une trace d'un programme est un moyen de suivre la séquence d'instructions au cours de leur exécution. En général, vous ne devriez pas en avoir besoin... mais cela peut devenir très utile pour pister les bugs, ou pour les exemples comme ceux que j'ai utilisés.
3. from et import sont deux mots-clés Python, comme le montre la couleur utilisée pour les écrire.
4. Malgré leurs noms, certaines des instructions définies dans "useful" peuvent donner des résultats inattendus si le robot n'est pas dans l'orientation prévue au moment de commencer leur exécution. Il peut se produire à peu près la même chose quand vous importez des "vrais" modules Python ; vous devez être au courant des suppositions qui sont faites pour la bonne utilisation du module. Je ne vous parlerai pas des suppositions faites dans le faux module "useful". Vous pouvez les découvrir en essayant d'écrire divers programmes par vous même.
5. Vous pouvez normalement lire le code Python (ou C) des modules dans la vraie vie, si vous cherchez à le faire. Cela peut être utile en l'absence de documentation, ou pour apprendre comment les programmeurs plus expérimentés écrivent leur code.
6. À cause de la nature restreinte du faux module importé, certaines instructions légitimes (par exemple, quand le mot-clé import apparaît dans un commentaire) peuvent donner une erreur rapportée par rur-ple.

3. Et si je veux utiliser le même nom

Supposez que vous vouliez utiliser le nom "turn_right" pour signifier autre chose que ce qui est défini dans useful. Il y a quelques façons de le faire.

1. Vous pouvez utiliser l'instruction import useful. En faisant cela, vous devez ajouter useful. avant le nom de chaque instruction. Par exemple
   useful.turn_right() et
   turn_right()
   représentent deux commandes différentes. La première est définie dans le module useful alors que la seconde devra être définie par vous-même autre part. En préfixant useful. avant chaque instruction, un lecteur peut immédiatement rapporter que ces instructions sont définies autre part [Nous verrons une autre signification de l'ajout de quelque chose comme useful. au nom d'une instruction plus tard quand nous parlerons de Programmation Orientée Objet (POO)].
   
2. Une deuxième manière de faire une chose semblable est la suivante :
   

   # Ce qui suit est utile pour les francophones :
   from useful import turn_right as vire_a_droite
   
   # Utilisation :
   vire_a_droite()
   turn_off()
       

4. Peut-être pas si utile après tout...

Si vous considérez l'utilité potentielle du module "useful" dans l'écriture de vos propres programmes... vous pourriez penser qu'il est trop limité pour être utile après tout. Vous pouvez refléter cela en écrivant ce qui suit :

# Importer le module
import useful as pas_si_useful_apres_tout

# Utiliser les diverses instructions :
pas_si_useful_apres_tout.turn_right()
pas_si_useful_apres_tout.turn_around()
turn_off()

# Importer le module
import module_avec_un_nom_très_très_très_long as nom_court

# Utiliser les diverses instructions :
nom_court.instruction1()
nom_court.instruction2()

5. Pourquoi donc importer ?

On dit souvent qu'avec Python on a les piles fournies (batteries included). Ce qui veut dire que Python inclut beaucoup de modules utiles écrits par des gens très intelligents. Ces modules ont été complètement testés pour être sans bugs et écrits d'une manière très efficace. Quand vous en apprendrez plus sur Python et vous voudrez écrire vos propres programmes "compliqués", il sera très profitable de déterminer d'abord si un module adéquat existe déjà qui pourrait vous aider dans votre tâche. Je vous présenterai quelques modules utiles dans des leçons ultérieures.

Remarque importante pour les enseignants : comme il en a été fait allusion ci-dessus, la raison de la restriction de l'utilisation des instructions d'importation est d'éviter que quelqu'un mette la main sur un script dangereux et le passe à une victime trop confiante. Remarquez que cela peut toujours être fait dans la fenêtre de l'éditeur Python mais, espérons-le, d'ici là les élèves en sauront assez pour vérifier les programmes donnés par des "amis" avant de les essayer. Cela étant dit, si vous êtes familier avec Python il est assez facile d'introduire un petit changement dans le code source de rur-ple pour permettre n'importe quelle instruction d'importation. Cela peut être utile dans la configuration d'une classe. Veuillez contacter l'auteur si vous avez besoin de faire cela et n'y arrivez pas tout seul.

Une touche de classe - - Évasions aléatoires