TigerJython

1.2 PREMIERS PAS

INTRODUCTION

Un programme informatique généralement en une suite d’instructions. Python permet d’exécuter de manière instantanée et interactive des instructions individuelles. Cela convient particulièrement bien pour une première utilisation de Python ou tester rapidement une idée. Pour cela, il faut cliquer sur l’icône de la console, ce qui va ouvrir la fenêtre de la console. Celle-ci permet de saisir une instruction sur la ligne débuttant par « >>> » qui sera exécutée avec la touche ENTER (Retour chariot). Comme dans tout éditeur, il est possible de naviguer à l’intérieur de la ligne à la souris ou au clavier à l’aide des touches directionnelles et d’insérer ou supprimer des caractères individuels. Aussitôt que la touche ENTER est enfoncée, la ligne d’instruction est exécutée, à moins qu’il s’agisse d’une instruction s’étendant sur plusieurs lignes. Dans ce dernier cas, lorsque toutes les lignes ont été saisies, il faut appuyer deux fois sur ENTER pour exécuter l’instruction saisie.

Il est possible de sélectionner les instructions déjà exécutées avec la souris et les copier avec Ctrl+C. On peut ensuite les coller le contenu du presse-papier sur la ligne de commande à exécuter avec Ctrl+V.

Il est possible également de naviguer dans l’historique des instructions exécutées avec les touches directionnelles haut et bas du clavier. Le caractère souligné représente le résultat de l’évaluation de la dernière instruction.

FAIRE CONNAISSANCE DE PYTHON

Voici quelques propositions d’instructions à exécuter. Laissez libre cours à votre imagination pour en tester d’autres. Démarrer TigerJython et cliquer le bouton Console.

Saisir les exemples ci-dessous dans la console pour observer comment Python effectue les quatre opérations arithmétiques de base:

>>> 4 + 13 17
>>> 2.5 - 5.7 -3.2
>>> 1356 * 22345 30299820
>>> 1 / 7 0.14285714285714285

Comme le montrent les exemples précédents, on peut utiliser des nombres entiers au décimaux. Les nombres entiers sont appelés integer (int) et les décimaux sont appelés float.

On peut exécuter plusieurs opérations dans une même instruction pour former des expressions plus complexes, comme en mathématiques. Il faut bien faire attention à la précédence des opérations qui s’applique comme en mathématiques, où * et / ont une priorité supérieure (on dit « précédence » en termes techniques) aux opérateurs + et -. Pour des opérations de même priorité, l’expression est évaluée de gauche à droite. Il est possible de rajouter des parenthèses dans l’expression comme en mathématiques pour regrouper les opérations qui sont à évaluer ensemble. Attention cependant à une petite différence d’avec la notation algébrique standard : il n’est possible d’utiliser que les parenthèses « rondes » () et non les parenthèses « carrées » [] qui ont une signification différente pour Python.

>>> (66 - 12) * 5 / 6
45.0

>>> 66 - 12 * 5 / 6
56.0

La division entière et le reste(opérateur modulo) sont également importants:

>>> 5 // 3
1

>>> 5 % 3
2

Python peut gérer sans problème des nombres très grands survenant par exemple avec l’opérateur d’exponentiation **

>>> 45**123
    22138041353571795138171990088959838587798501812515796
    35495262099494113535880540560608088894435720496058262
    03407737866682728901508127084151522949268748976128137
    6128136645054322872994134741020388901233673095703125L

Il y a beaucoup de fonctions intégrées, par exemple<:

>>> abs(-9)
9

>>> max(1, 5, 2, 4)
5

D’autres fonctions sont disponibles après l’importation des modules externes respectifs. Il est possible d’importer de deux manières différentes des modules supplémentaires. Avec la première variante (à gauche), l’appel de la fonction se fera en faisant précéder le nom de la fonction par le nom du module qui la définit. Dans la deuxième variante (à droite), les fonctions sont importées dans l’espace de nom global et peuvent être appelées directement sans les précéder du nom du module. Dans un très court programme, la deuxième version convient très bien mais on préfère généralement la première variante dans les projets plus complexe.

>>> import math
>>> math.pi
3.141592653589793
>>> math.cos(pi)
-1

>>> from math import *
>>> pi
3.141592653589793
>>> sin(pi)
1.2246467991473533e-16

On peut observer au passage que l’ordinateur ne calcule jamais de manière exacte puisque sin(pi) vaut théoriquement exactement 0.

Une suite de caractères (lettres, ponctuation, …) est appelée chaine de caractères (string en anglais) et on peut les définir en utilisant des guillemets simples ou doubles. Il est possible d’écrire des chaînes de caractères et d’autres valeurs vers la fenêtre de sortie à l’aide de la commande print. La virgule permet de séparer plusieurs valeurs à afficher. L’instruction

>>> print "Le résultat est", 2

Produit la sortie suivante dans la fenêtre: Le résultat est 2

Comme en mathématiques, on peut assigner des valeurs à des variables. Pour ce faire, on utilise un identifiant (identifier en anglais) comportant une ou plusieurs lettres. Certains caractères ne sont pas autorisés pour les identifiants tels que les espaces, les guillemets, les caractères accentués ou tout autre caractère spécial.

Un des avantages des variables est de stocker le résultat d’un calcul précédemment effectué pour éviter de devoir le refaire plus tard. Le panneau droit de la console TigerJython est fort pratique puisqu’il affiche les identifiants connus. Les variables définies dans la ligne de commande sont visibles dans l’espace de nom intitulé Globals.

>>> a = 2
>>> b = 3
>>> sum = a + b
>>> print "La somme de", a, "et", b, "est", sum

Produit la sortie suivante: La somme supprimer de 2 et 3 est 5

Une collection ordonnée d’éléments de type quelconque est nommée une liste. Les listes constituent un type de données extrêmement utile et incontournable dans tous les langages de programmation (d’autres langages appellent ce type de données des tableaux). En Python, on définit une liste en énumérant ses différents éléments séparés par une virgule et entre crochets carrés. On peut également afficher les listes dans la sortie du programme avec l’instruction print.

>>> li = [1, "chicken", 3.14]
>>> print li

Dans la fenêtre de sortie: [1, "chicken", 3.14]

Les listes et d’autres objets possèdent des fonctions associées appelées méthodes. Celles-ci permettent d’agir sur les objets auxquels elles sont rattachées. Il est par exemple possible d’ajouter de nouveaux éléments à la fin d’une liste à l’aide de la méthode append().

>>> li.append("egg")
>>> print li

Ce qui produit la sortie: [1, 'chicken', 3.14, 'egg']

Il est également possible de définir ses propres fonctions. Pour ce faire, on utilise le mot-clé def. On indique la valeur de retour de la fonction à l’aide du mot-clé return. Après qu’une fonction a été définie, il est possible de l’appeler de la même manière que les fonctions prédéfinies par Python :

>>> def sum(a, b):
>>> return a + b
>>> sum(2, 3)

ENVOYER DES COMMANDES À LA TORTUE

La console est fort utile pour tester rapidement quelques commandes ou fonctions. Par exemple, pour se familiariser avec le module de graphique tortues, il faut d’abord importer le module gturtle et créer ensuite une fenêtre comportant une tortue avec la commande makeTurtle().

>>> from gturtle import *
>>> makeTurtle()

Suite à ces instructions, toutes les commandes comprises par la tortue sont à disposition. Par exemple :

forward(100)	Raccourci: fd(100)	Avancer la tortue de 100 pixels
back(50)	Raccourc: bk(50)	Reculer la tortue de 50 pixels
left(90)	Raccourc: lt(90)	Tourner de 90° vers la gauche
right(90)	Raccourc: rt(90)	Tourner de 90° vers la droite
clearScreen()	Raccourc: cs()	Effacer toutes les traces et replacer la tortue au centre de la fenêtre

Exemple::

>>> fd(100)
>>> dot(20)
>>> rt(90)
>>> fd(100)
>>> dot(20)
>>> home()

Avec le mot-clé repeat, on peut exécuter plusieurs fois de manière répétée une ou plusieurs instructions. Pour exécuter de manière répétée une suite de commandes en tant que bloc d’instructions, il faut qu’elles soient toutes indentées de manière cohérente.

>>> repeat 4:
fd(100)
rt(90)

Comme le montre un exemple précédent, il est possible de combiner plusieurs instructions sous un nom personnalisé en définissant une fonction. L’avantage principal des fonctions est qu’elles permettent d’exécuter aussi souvent que désiré plusieurs instructions à l’aide du nom de cette fonction. Cela permet d’éviter de retaper les mêmes suites d’instructions à plusieurs endroits du programme.

>>> def drawSquare():
      repeat 4:
         fd(100)
         rt(90)

>>> drawSquare()
>>> rt(180)
>>> drawSquare()

Pour bien apprendre la programmation, il ne faut pas hésiter à essayer par soi-même en essayant pour le plaisir d’autres instructions que celles proposées dans le texte. On peut trouver un aperçu des différentes commandes comprises par la tortue dans la r documentation du module gTurtle. Cette documentation fait partie d’un chapitre qui montre de manière systématique comment développer des programmes complets.