Le cours python numéro 3 qui traite les types de données.

VARIABLES

Tous les langages de programmation permettent l’utilisation de variables, c’est-à-dire de noms alphanumériques auxquels on peut attribuer une valeur. Nous ouvrons IDLE et écrivons :

>>> a = 5

Nous remarquons d’abord que cette fois IDLE ne nous répond pas en écrivant quelque chose. En fait, ce que nous avons écrit n’est pas une expression, mais une instruction d’un autre type appelée affectation.

Une instruction d’affectation est donnée par la syntaxe :

nom_variable = expression

Lorsque Python rencontre ce type d’instruction, il calcule le résultat de l’expression à droite du signe = et l’affecte à la variable à sa gauche.

Pour voir la valeur de notre variable, il suffit de taper son nom (en fait, même le nom unique d’une variable est une expression pour Python). Nous continuons à écrire :

>>> a
5
>>> b = 3 * 5**2
>>> b
75
>>> c = "Mamma"
>>> c
'Mamma'
>>> d = False
>>> d
False

Notez que c a reçu la chaîne “Maman” (écrite entre guillemets), tandis que d a la valeur booléenne False (sans guillemets, ce n’est pas une chaîne).

Une fois que nous avons attribué une valeur à une variable, nous pouvons ensuite l’utiliser dans des expressions. On peut aussi lui attribuer une nouvelle valeur, qui remplace la précédente. Continuons ainsi :

>>> 2 * a
10
>>> a + b
80
>>> x = a * (b - 50)
>>> x
125
>>> x = 2
>>> x
2
>>> 4 * c
'MammaMammaMammaMamma'
>>> c and (1 > 0)
False

Cependant, nous ne pouvons pas utiliser une variable si nous ne lui avons pas attribué une valeur au préalable. La règle est simple :

La première fois que nous utilisons une nouvelle variable, elle doit apparaître à gauche dans une instruction d’affectation.

Nous notons que lorsque nous attribuons une valeur à une variable IDLE, elle “se souvient” de cette valeur également dans les instructions suivantes (en fait, dans cette leçon, je suppose que vous écrivez les lignes de code dans les différentes cases dans l’ordre dans lequel je présente eux, sans jamais quitter l’application). Si nous voulons que IDLE “oublie” toutes les variables, nous pouvons utiliser l’élément de menu Shell => Restart Shell (ne le faites pas pour l’instant).

Essayons plutôt ceci :

>>> a = y + 2
Traceback (most recent call last):
  File "<pyshell#41>", line 1, in <module>
    a = y + 2
NameError: name 'y' is not defined

Nous avons utilisé la variable y sans lui attribuer au préalable une valeur : Python répond par un NameError en nous montrant la ligne de code qui a causé l’erreur et en nous donnant une description (le nom y n’est pas défini).

En informatique, les noms de variables ne sont pas limités à une lettre, mais peuvent être aussi longs que nous le voulons afin que nous puissions créer des noms qui nous rappellent le contenu de la variable. Nous avons des règles simples pour former de tels noms :

Le nom d’une variable ne peut contenir que des lettres, des chiffres et le caractère _ (trait de soulignement)
Il ne peut pas commencer par un chiffre
Il ne peut pas être identique à l’un des mots réservés de Python
Les majuscules et les minuscules sont considérées comme différentes (en anglais, la langue est dite sensible à la casse).
Voyons quelques exemples :

>>> peppe = 5
>>> peppe123 = 6
>>> peppe_e_pippo = 3
>>> Peppe = 2

Ce sont OK. peppe et Peppe sont deux variables différentes (peppe contient 5 et Peppe 2).

>>> 123mamma = 2
SyntaxError: invalid syntax
>>> while = 1
SyntaxError: invalid syntax
>>> peppe@pippo = 4
SyntaxError: invalid syntax

Celles-ci, en revanche, ne sont pas bonnes ; while est un mot réservé Python (nous en reparlerons plus tard).

LA DIFFÉRENCE ENTRE = ET ==

Le signe = dans une affectation ressemble au signe d’égalité trouvé entre les deux membres d’une équation en mathématiques. Nous réitérons, cependant, que cela n’a rien à voir avec l’égalité entre les deux membres, mais cela signifie que d’abord l’expression à droite de celle-ci est calculée, puis son résultat est stocké dans la variable à gauche. Cela est particulièrement évident lorsque nous attribuons à une variable le résultat d’une expression qui contient la variable elle-même, ce qui n’aurait pas de sens en mathématiques.

>>> a = 5
>>> a = a + 2
>>> a
7
>>> a = a + 3
>>> a
10
c = "Mamma"
>>> c = "Ciao " + c + "!"
>>> c
'Ciao Mamma!'

Si nous voulons être pédants, nous ne devrions pas lire le premier exemple comme “a est égal à plus deux”, mais “a reçoit la valeur de plus deux”. Pour cette raison, Python utilise deux symboles différents : = dans une affectation et == dans une expression booléenne : en écrivant 3 = 5, vous obtenez une erreur, car Python l’interprète comme une tentative d’assigner la valeur 5 non pas à une variable, mais à un constante (le nombre 3).

Les affectations telles que a = a + 1 sont si fréquentes qu’il existe une syntaxe abrégée spéciale en Python. Ainsi a = a + 2 peut être abrégé par a + = 2, a = a * 3 peut être abrégé par a * = 3 et ainsi de suite pour chaque opérateur mathématique (comme d’habitude vous ne pouvez pas laisser d’espaces entre + = car ils représentent un seul opérateur).

>>> a = 4
>>> a += 1
>>> a
5
>>> a -= 10
>>> a
-5

TYPES DE DONNÉES

Avant de continuer, il est nécessaire de s’arrêter un instant pour réfléchir aux similitudes et aux différences entre les nombres et les chaînes. Nous avons vu que nous pouvons faire des opérations sur les deux : en ajoutant deux nombres le résultat est ce que l’on attend en mathématiques, en ajoutant deux chaînes on obtient leur concaténation. Nous pouvons multiplier deux nombres ensemble, mais pas deux chaînes ensemble (si nous essayons, nous obtenons une erreur). En utilisant des variables, les choses se compliquent : l’instruction a * b peut être légale (si a et b sont deux nombres ou un nombre et une chaîne) ou donner une erreur (s’il s’agit de deux chaînes). Disons qu’un nombre et une chaîne sont deux types de données différents.

En informatique, le type de données détermine quelles valeurs elle peut prendre et quelles opérations peuvent être effectuées dessus.

Lorsque nous attribuons une valeur à une variable, Python se souvient du type de données qui y est stockée. Nous tapons ces expressions dans IDLE, en faisant attention aux parenthèses (nous clarifierons leur syntaxe et leur signification dans la prochaine leçon).

>>> type("Mamma")
<class 'str'>
>>> a = 1234
>>> type(a)
<class 'int'>
>>> b = 12.34
>>> type(b)
<class 'float'
>>> c = True
>>> type(c)
<class 'bool'>

Python a répondu que “Mom” est de type “str”, c’est-à-dire une chaîne, a est de type “int” (entier), b est un flottant (nombre avec une virgule) et c est un booléen.

Notons que les entiers et les nombres avec virgules sont deux types de données différents pour Python : cela dérive de l’architecture interne de la mémoire et du processeur. Pour l’ordinateur, il est beaucoup plus facile et rapide de manipuler des nombres entiers que des nombres avec des virgules. Gardez à l’esprit qu’un processeur 64 bits comme ceux qui équipent actuellement un PC peut additionner deux entiers jusqu’à 264 en une seule instruction, alors qu’il doit effectuer de nombreuses opérations, par exemple, pour la somme 0,1 + 0,01 entre deux nombres avec la virgule. Ainsi, Python, comme presque tous les langages de programmation, fait la distinction entre les nombres entiers et flottants. Par exemple, IDLE écrira 4 s’il considère 4 comme un entier et 4.0 s’il le considère comme un flottant.

Si ce que j’ai dit vous semble un peu obscur, ne vous inquiétez pas : Python essaie toujours d’éviter les complications et donc en général nous n’aurons pas à nous soucier beaucoup de cette distinction. En fait sur les deux types de nombres vous pouvez faire les mêmes opérations (ce qui change c’est seulement la manière dont Python les exécute en interne) ; de plus Python convertit automatiquement les valeurs lorsque cela est nécessaire : dans toutes les opérations il suffit qu’un des deux opérandes soit flottant pour que le résultat soit également converti en flottant ; la division dont le résultat est toujours flottant est une exception. Voici quelques exemples (notez que les nombres sans point sont int, ceux avec un point float):

>>> 15 / 5
3.0
>>> 15 // 5
3
>>> 10 + 15 / 5
13.0
>>> 10 + 15 // 5
13
>>> 10.0 + 15 // 5
13.0

Certains langages de programmation (par exemple C) sont très stricts sur les types de données et nécessitent la déclaration de variables : avant d’utiliser une variable a, il est nécessaire d’écrire une instruction qui dit au langage « J’ai l’intention d’utiliser une variable a qui contient un entier “, après quoi dans cette variable je ne peux mettre que des nombres entiers. Cela permet au langage de savoir à l’avance combien de mémoire occupera la variable a et ainsi de faciliter sa mémorisation.

Python, comme nous l’avons vu, ne nécessite pas la déclaration (il faut juste penser à toujours affecter une valeur à la variable avant de faire toute autre utilisation) et il permet aussi d’affecter différents types à une même variable. Cela fait partie de la “philosophie” de Python d’essayer de cacher tout le travail qu’il fait dans la mémoire de l’ordinateur afin que l’utilisateur n’ait pas à s’en soucier.

>>> a = 5
>>> a = 6.0
>>> a = "Mamma"

Nous avons d’abord affecté à la même variable un entier, puis un flottant et enfin une chaîne. Python a probablement fait beaucoup de travail en mémoire, allouant et libérant des cellules, mais nous ne le remarquons pas vraiment.