SHS: Objectif Code
Jouons avec Python - Des chiffres et des lettres
Attention: utilisateurs de Windows, vous devez avoir installé python avant d'aller plus loin ici.
Ainsi que vous soyez sous Windows, Linux ou Mac, rien de plus facile que d'utiliser python, directement en ligne de commande:
1. On ouvre un Terminal (ou une "invite de commande" sur windows)
2. On tape "python"
3. Ceci devrait apparaître
Python 2.7.8 (default, Nov 13 2014, 13:17:03)
[GCC 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2336.1.00)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
Où suis-je ?
Vous voilà arrivé(e) sur "l'interpréteur de commande python" qui exécute du code... Python. Quelque part, la programmation, c'est simple: on dit "fais ceci" à la machine et la machine s'exécute. Un programme "n'est qu'une" série d'instructions qui peuvent suivre une exécution linéaire (les unes après les autres) et/ou en simultané (plusieurs tâches en même temps).
L'interpréteur que vous avez sous les yeux permet de tester du code python: on écrit une commande puis on tape sur entrée. Assez parlé, faisons ce qui constitue le premier programme de n'importe quel débutant absolu en programmation, à savoir le "hello world", ridiculeusement facile en python:
>>> print('hello world')
hello world
>>>
Voilà, vous avez exécuté votre première commande en python! - Nous y reviendrons plus tard.
Des chiffres et des lettres
Essayons quelque chose de tout bête, à savoir taper 1 puis entrée :
>>> 1
1
>>>
Puis faisons:
>>> 1 + 2
3
>>>
Vous l'aurez deviné: ici, rien de bien compliqué: on a commencé par rentrer le chiffre 1 et notre interpréteur interprète cela en nous affichant... 1. Cette commande ne présente évidemment aucun intérêt. Par contre, la commande suivante nous permet de réaliser un petit calcul avec 1+2 qui, selon l'interpréteur donne... 3. Evidemment, vous pouvez faire toutes sortes de calculs:
>>> 9-1 # la soustraction
8
>>> 5*3 # la multiplication
15
>>> 10/2 # la division
5
>>> 2**2 # la puissance
4
Comme nous n'en sommes qu'aux premiers pas, je ne vais pas plus loin avec les chiffres et les nombres. Nous aurons l'occasion d'aborder le sujet à nouveau.
Essayons maintenant de jouer un peu avec des "caractères" ("le nom informatique" pour désigner une lettre mais aussi des signes comme la virgule, l'espace, parenthèse, etc...):
>>> 'a' # pensez aux guillemets (par paire) !!!
'a'
>>> "b"
'b'
>>> 'azerty'
'azerty'
>>> 'a' + "zerty" # les deux types de guillemets peuvent être utilisés dans une expression
'azerty'
>>> 'a' + " " + "zerty"
'a zerty'
Comme avec les chiffres, nous avons ici affiché les lettres 'a' puis 'b' suivies de la chaîne de caractère "azerty". Les commandes suivantes effectuent ce qu'on appelle une "concaténation" (qui permet d'additionner des caractères, chaînes de caractères entre eux), ici 'a' + 'zerty' donne 'azerty'. En insérant un espace (" ") dans "l'opération", l'interpréteur l'ajoute naturellement et affiche le résultat de la concaténation: 'a zerty'.
Si vous avez bien utilisé les '' (simples guillemets ' ) ou "" (doubles guillemets " ) pour délimiter vos caractères ou "chaînes de caractères", vous devriez avoir le même résultat que ci-dessus. Si non, vous avez dû avoir ceci:
>>> "a
File "", line 1
"a
^
SyntaxError: EOL while scanning string literal
ou alors :
>>> a
Traceback (most recent call last):
File "", line 1, in
NameError: name 'a' is not defined
Voici ce qu'on appelle deux messages d'erreurs que l'interpréteur nous a renvoyés. En gros, on peut dire qu'il n'est pas content et qu'il "râle" (très courtoisement). Si vous persévérez un tant soit peu dans la programmation, votre évolution dépendra énormément de votre appétence à comprendre ces messages d'erreurs: ils sont généralement pénibles, souvent déroutants, mais bien comprendre son erreur (et donc l'exception levée quand celle-ci a lieu) permet d'acquérir, petit à petit, une meilleure compréhension du code et du fonctionnement des machines.
Ces messages d'erreurs apparaissent car derrière nos petites commandes 1+2, 'azerty', l'interpréteur "met en branle" toute une série d'instructions que nous ne voyons pas. Comme promis, je ne rentre pas dans des considérations trop techniques mais ce détail est important.
En effet, pour que nous puissions réaliser le programme du débutant, le "hello world", avec un simple "print('hello world')", il a fallu que des informaticiens écrivent toute une série de programmes à partir d'autres langages de programmation. En gros, pour éviter d'avoir à écrire 20 lignes de code pour "imprimer" (print) un simple texte (ou un nombre, etc... - ici "hello world") sur un terminal, eh bien ces messieurs ont inventé, tout langage (le python donc) qui nous facilite grandement la tâche (merci monsieur van Rossem). Et quand notre code ne correspond pas aux règles définies par les personnes qui génèrent le code python (il n'est pas seul), nous recevons un message aussi proche que possible de l'erreur, afin de nous indiquer éventuellement où farfouiller et aussi, accessoirement, d'éviter de planter tout le système.
Revenons à nos deux messages d'erreur. Dans le premier, un guillemet manque. L'interpréteur commence donc par lire la ligne avec le premier guillemet, se dit "voilà un caractère ou une chaîne de caractères", reçoit le premier caractère puis... la touche entrée est actionnée sans que le guillemet ne soit fermé. Patatra, l'interpréteur répond: "votre instruction n'est pas correcte (SyntaxError): je suis arrivé au bout de la ligne (EOL = End Of Line) sans trouver une fin (le guillemet fermant) à la chaîne que j'étais en train de scanner (while scanning string literal)".
Dans le second message, l'interpréteur dit qu'il ne sait pas ce que 'a' (sans les guillemets, pour le coup - dans la commande) signifie, il nous répond
name 'a' is not defined
En gros: "le nom 'a' n'est pas défini": python sait reconnaître un chiffre (1) ou un caractère ("a"), une chaîne ("azerty") mais la lettre a directement envoyée à l'interpréteur (sans guillemets) ne correspond à rien.
Mais si on essaie ceci:
>>> a = 'a'
>>> a
'a'
Ici plus d'erreur quand on tape la lettre a: nous avons commencé par créer une VARIABLE (a=) puis nous lui avons assigné une valeur ('a') - la logique est en fait inverse (nous avons assigné la valeur 'a' dans la variable a) mais comme convenu, j'essaie de faire au plus simple.
Désormais, l'interpréteur sait que la lettre a renvoie au caractère 'a'. Aussi:
>>> a = 'a'
>>> b = 'zerty'
>>> a + b
'azerty'
Je vous laisse imaginer les possibilités:
>>> a = 6
>>> b = 2
>>> a + b
8
>>> a - b
4
>>> a * b
12
>>> a / b
3
>>> a**b
36
Ou bien:
>>> a = "je m'appelle " # remarquez qu'imbriquer un simple guillemet dans un double ne pose pas de problème
>>> b = "Jean-Paul"
>>> a + b
"je m'appelle Jean-Paul"
>>> n = 5
>>> b * n # on multiplie une chaîne par un nombre!!!
'Jean-PaulJean-PaulJean-PaulJean-PaulJean-Paul'
>>> (a + b) * n # soyons fous
"je m'appelle Jean-Paulje m'appelle Jean-Paulje m'appelle Jean-Paulje m'appelle Jean-Paulje m'appelle Jean-Paul"
>>> a + n # par contre
...Traceback (most recent call last):
File "", line 1, in
TypeError: cannot concatenate 'str' and 'int' objects
Arf. C'était trop beau pour continuer. L'interpréteur râle... Que dit-il?
"Erreur de Type: impossible de faire la concaténation d'une chaîne avec un nombre".
Autant nous pouvons multiplier une chaîne par un nombre (et donc la répéter autant de fois) mais nous ne pouvons pas "concaténer" la lettre 'a' et le chiffre 5 (l'addition n'aurait elle aucun sens). Par contre:
>>> a + str(n)
"je m'appelle 5"
... ne veut rien dire mais fonctionne parfaitement!
Qu'avons-nous fait? Nous avons modifié la "nature" de la variable n avec la fonction str() - str correspond à "string" = chaîne de caractères en Anglais. Celle-ci consiste à "forcer" le passage d'un nombre en caractère (ou chaîne de caractères).
Nous sommes ainsi passés de "chaîne a + nombre n" avec une erreur à "chaîne a + chaîne(nombre n)" sans erreur.
Retenons de suite que la variable a est de type "string" alors que n est type "int" (=integer = nombre entier). D'où le message d'erreur quand on additionne naïvement les deux variables:
TypeError: cannot concatenate 'str' and 'int' objects
Evidemment, l'opération "nombre + chaîne" ne fonctionne pas non plus. Mais imaginons que nous ayions un nombre n = 5 et un caractère a = '5'.
Comme prévu:
>>> n = 5 >>> a = '5' >>> a + n Traceback (most recent call last): File "", line 1, in TypeError: cannot concatenate 'str' and 'int' objects
Mais:
>>> int(a) + n 10
Ici nous avons forcé le passage de la variable "string" a (qui contient le caractère '5') en "int" (le chiffre 5) puis nous l'avons additionné à la variable n qui est de type "int". L'interpréteur exécute donc l'addition sans problème.
Evidemment, si vous essayez des choses du genre "int('10a') + 5", l'interpréteur ne sera pas content... Ca ne lui pose pas de problème de reconnaître un nombre contenu dans une chaîne tant que celle-ci ne contient qu'un ou des caractères numériques.
Attardons-nous sur un des mots du message d'erreur: "objects". L'objet, en programmation, c'est tout un concept. Nous l'effleurons ici avec le message d'erreur qui nous dit qu'il ne peut pas concaténer un objet "string" et un objet "integer". Prenez le pour acquis: en Python, tout est objet. Le moindre caractère, le moindre nombre sont des objets. Et chaque objet a un type. Tout est prévu en Python pour se repérer:
>>> type(5) # on demande à l'interpréteur "de quel type est le chiffre 5 ?"
<type 'int'> # il nous répond: type entier!
>>> type('5') # ... le caractère "5"?
<type 'str'> # ... type chaîne!
>>> type('a') # le caractère 'a'?
<type 'str'>
>>> a = 'azerty'
>>> type(a) # sans guillemets donc car on teste la variable
<type 'str'> # la variable a est de type chaîne
>>> b = 6
>>> type(b) # type de la variable b ?
<type 'int'> # entier !
>>> c = '3'
>>> type(b+int(c)) # on "caste" c en int
<type 'int'> # le résultat de l'addition est bien un entier
>>> type(str(b) + c) # on "caste" b en string
<type 'str'> # le résultat de la concaténation est bien une chaîne
Profitons de notre petite commande type() pour aborder le cas des nombres à virgule (décimaux). Essayons ceci:
>>> 0.93
0.93
>>> type(0.93)
<type 'float'>
>>> 93/100
0
>>> type(93/100)
<type 'int'>
Bon, ça se complique un peu mais ce n'est pas grand chose: nous avons ici un premier nombre 0.93 de type "float" (flottant = nombre à virgule) puis une opération qui aurait dû aboutir au même résultat (93/100=0.93). Or nous obtenons la valeur 0 et perdons les "chiffres après la virgule".
Ici, l'interpréteur réalise une opération à partir de deux entiers (93 et 100) et renvoie, c'est comme ça, un résultat de type entier. Si en revanche, un de nos deux nombres avait été du type "float" (même sans nombre après la virgule), voici ce que nous aurions obtenu:
>>> float(93)/100 # je force le passage en float de 93
0.93
>>> type(float(93)/100) # quel est le type du résultat?
<type 'float'>
>>> 93./100 # beaucoup plus simple: je rajoute un "." pour avoir "93."
0.93
>>> type(93.) # de quel type est 93. ???
<type 'float'> # même sans nombre après la virgule, 93. est bien un flottant
Voilà, nous avons parcouru un petit bout de chemin et mieux vaut prendre le temps de "digérer" tout cela... Jusque maintenant, tout devrait vous paraître relativement simple. Pour vos premiers travaux pratiques, amusez-vous à réaliser quelques opérations et quelques concaténations à partir de variables, en tester le type mais aussi, apprenez à utiliser la commande print en l'utilisant pour afficher le résultats de vos commandes, par exemple:
>>> message = "Bonjour"
>>> prenom = "Jean-Paul"
>>> print(message + ' ' + prenom)
Bonjour Jean-Paul
Puis rendez-vous dans la section suivante!