Les types et variables

Les variables en python.

Pendant l’exécution d’un programme, les données que ce dernier manipule sont stockées en mémoire centrale. En nommant ces données, on peut les manipuler beaucoup plus facilement. Les variables nous permettent donc de manipuler ces données sans avoir à se préoccuper de l’adresse explicite qu’elles occuperont effectivement en mémoire. Pour cela, il suffit de leur choisir un nom ou identificateur. L’interpréteur (programme de traduction) s’occupe d’attribuer une adresse à chaque variable et de superviser tous les éventuels futurs changements d’adresse. Une variable peut-être assimilée à une boîte aux lettres portant un nom. Par exemple x = 2 signifie : « à l’adresse mémoire référencée par x-autrement dit, dans la boîte aux lettres dénommée x-, se trouve la valeur 2 ». Nous utilisons plus fréquemment l’abus de langage « la variable x vaut 2 ».

Affectation

L'instruction :

>>>x = 2

L'instruction

>>>x = x+1

Affectations multiples

Sous python, on peut affecter une valeur à plusieurs variables simultanément :

>>>a=b=2
>>>a
2
>>>b
2
>>>

Affectations parallèles

On peut aussi effectuer des affectations parallèles à l'aide d'un seul opérateur :

>>>a,b=2,3
>>>a
2
>>>b
3
>>>

Etant donnée la liberté autorisée dans le choix du nom des variables, il est préférable, pour améliorer la lisibilité des programmes, de choisir des noms de variables en fonction de ce qu’elles représentent réellement. Préférez des noms parlants tels que couleur, taille ou prix à x, y ou z.

En Python, la simple déclaration d’une variable ne suffit pas à la créer. Après avoir choisi son nom, il est nécessaire de lui affecter une valeur initiale.

Exemple

>>>nombrePrefere = 16
>>>motPreferee =  " liberté ! "
>>>pi = 3.14159

L’ordinateur ne sait pas faire l’addition de plus de deux nombres mais cela suffit à calculer la somme de n premiers entiers. Pour cela, il est nécessaire de créer une variable intermédiaire qu’on appellera par exemple somme de manière à conserver le résultat des sommes intermédiaires.

Exemple

>>> somme=0	# initialisation : la somme est nulle
>>> for i in range(1 , 10) :		# pour tous les indices de 1 à 10 exclu
...     somme = somme + i	# on ajoute le ième élément à somme
... 
>>> somme		# somme de tous les entiers postif de 1 à 9.
45
>>>

Remarques

1. Le symbole # apparaîtra à maintes reprises. Il marque le début d’un commentaire que la fin de la ligne termine. Autrement dit, un commentaire est une information aidant à la compréhension du programme mais n’en faisant pas partie comme dans l’exemple ci-dessus.
2. Le langage Python impose une instruction par ligne. Il n’est pas possible d’utiliser deux lignes pour écrire une affectation à moins de conclure chaque ligne qui n’est pas la dernière par le symbole \. L’exemple suivant est impossible.

   a = 			
   	16.3

   Il devrait être rédigé comme suit :

   a = \			
   	16.3

   Avec ce symbole, les longues instructions peuvent être écrites sur plusieurs lignes de manière lisible, de sorte qu’elles apparaissent en entier à l’écran.

3. Une variable est caractérisée par :

   • Un identificateur : il peut contenir des lettres, des chiffres, des blancs soulignés mais il ne peut commencer par un chiffre. Minuscules et majuscules sont différenciées. Il est aussi unique.
   • Un type c’est une information sur le contenu de la variable qui indique à l’interpréteur Python la manière de manipuler cette donnée.

Les types de variables en python.

Comme le montre l’exemple 1, différents types d’information (nombres, chaînes de caractères …) peuvent être placés dans une variable et il est capital de connaître comment la valeur qui s’y trouve a été codée. Cette distinction correspond à la notion de type, fondamentale en informatique car elle débouche sur le codage binaire de la variable (par exemple, un entier numérique sur 32 bits, un réel sur 64 bits et un caractère sur 16 bits) ainsi que sur les usages qui peuvent en être faits (on ne peut pas multiplier un caractère par un nombre). Dans le paragraphe suivant on énumère les types incontournables en Python.

Python propose un type None pour signifier qu’une variable ne contient rien. La variable est de type None et est égale à None.

s = None
print(s)		#   affiche None

Certaines fonctions (voir le chapitre sur les fonctions) utilisent cette convention lorsqu’il leur est impossible de retourner un résultat.

Il existe deux types de nombres en Python, les nombres réels (float) et les nombres entiers (int). L’instruction x = 5 crée une variable de type int initialisée à 5 tandis que y = 5.0 crée une variable de type float initialisée à 5.0. Le programme suivant permet de vérifier cela en affichant les variables x et y, leurs valeurs et leurs types respectifs grâce à la fonction type.

x = 5
y = 5.0
print ("x =", x, type(x))		 						
print( "y =", y, type(y))

ce qui affiche :

x = 5 <class 'int'>
y = 5.0 <class 'float'> 

Exemple 3

a=9+7
print('Valeur de a : ',a)
print('Type de a : ',type(a))

b=9/4
print('Valeur de b : ',b)
print('Type de b : ',type(b))

c=9//4
print('Valeur de c : ',c)
print('Type de c : ',type(c))


d=9.+7
print('Valeur de d : ',d)
print('Type de d : ',type(d))

Ce qui affiche :

Valeur de a :  16
Type de a :  <class 'int'>
Valeur de b :  2.25
Type de b :  <class 'float'>
Valeur de c :  2
Type de c :  <class 'int'>
Valeur de d :  16.0
Type de d :  <class 'float'>

Voir Types numériques pour la liste des opérateurs qui s’appliquent aux nombres réels et entiers.

Les fonctions int et float permettent de convertir un nombre quelconque ou une chaîne de caractères respectivement en un entier (arrondi à 'unité) et en un nombre réel.

Exemple 4

x = int (12.7)
y = float (7)
z = int ("7")
print ("x = ", x," : ", type(x))
print (" y = ",y, " : ", type(y))
print (" z = ", z," : ", type(z))

Ce qui affiche :

x = 12 :  <class 'int'>
y = 7.0 :  <class 'float'>
z = 7 :  <class 'int'>

Remarque : Conversion en un nombre entier

Il peut arriver que la conversion en un nombre entier ne soit pas directe. Dans l’exemple qui suit, on cherche à convertir une chaîne de caractères (voir le paragraphe suivant) en entier mais cette chaîne représente un réel. Il faut d’abord la convertir en réel puis en entier, c’est à ce moment que l’arrondi sera effectué.

i = int ("3.5") 
print ("i = ", i)

Ce qui affiche :

ValueError: invalid literal for int() with base 10: '3.5'

En revanche :

i = int (float"3.5") 
print ("i = ", i)

fonctionne et affiche :

 i = 3 

Les booléens

Les booléens sont le résultat d’opérations logiques et ont deux valeurs possibles : True ou False.

x = 3 < 4
y = not x
print('x = ',x, ", Type de x :  ",type(x))
print('y = ',y, ", Type de y :  ",type(y))

Ce qui affiche :

x =  True , Type de x :   <class 'bool'>
y =  False , Type de y :   <class 'bool'> 

Le terme "chaîne de caractères" ou string en anglais signifie une suite finie de caractères qui ne sont pas seulement des lettres mais ils peuvent être aussi des nombres, <, @,*,%, etc,.. ou un mélange . Cette suite de caractères est comprise entre deux guillemets ou deux apostrophes, ces deux symboles sont interchangeables.

Il ne faut pas confondre la partie entre guillemets ou apostrophes, qui est une constante, de la variable qui la contient.

Exemple 5

t = "string@texte"
print('t = ', t)
print('Type de t : ',type(t))

x=str(3.8)
print('x = ', x)
print('Type de x : ',type(x))

y='3.8'
print('y = ', y)
print('Type de y : ',type(y))

z=float('3.8')
print('z = ',z)
print('Type de z : ',type(z))

Ce qui affiche :

t =  string@texte
Type de t : <class 'str'>
x =  3.8
Type de x :  <class 'str'>
y =  3.8
Type de y :  <class 'str'> 
z =  3.8
Type de z :  <class 'float'> 

Remarque

Regardons le programme suivant :

z = 'string = texte, initialisation avec apostrophes'
print( "la valeur de z : ", z, type (z))
x = "morceau1" \
"morceau2" 				
print ("x = ",x)                       	# il ne doit rien y avoir après le symbole \,
                                	# pas d’espace ni de commentaire	
y = """première ligne 			
        seconde ligne""" 	# chaîne de caractères qui s’étend sur deux lignes
print ("y = ", y)

Le résultat de ce petit programme est le suivant :

la valeur de z :  string = texte, initialisation avec apostrophes <class 'str'>
x = morceau1morceau2
y = première ligne 			
           seconde ligne

La troisième chaîne de caractères créée lors de ce programme s’étend sur deux lignes. Il est parfois plus commode d’écrire du texte sur deux lignes plutôt que de le laisser caché par les limites de fenêtres d’affichage. Python offre la possibilité de couper le texte en deux chaînes de caractères recollées à l’aide du symbole \ à condition que ce symbole soit le dernier de la ligne sur laquelle il apparaît. De même, lorsque le texte contient plusieurs lignes, il suffit de les encadrer entre deux symboles """ ou """ pour que l’interpréteur Python considère l’ensemble comme une chaîne de caractères et non comme une série d’instructions.

Par défaut, Python ne permet pas l’insertion de caractères tels que les accents dans les chaînes de caractères, pour résoudre ce problème, il faut ajouter une ligne placée en première position du programme qui précise que des accents pourront être utilisés. S’il fallait utiliser des caractères autres que latins, il faudrait alors choisir lejeu de caractères utf - 8 qui s’appliquent aussi aux langues orientales.

Remarque

Pour insérer un guillemet dans une chaîne de caractères encadrée elle-même par des guillemets, il faut le faire précéder du symbole \. La séquence \" est appelée un extra-caractère (voir tableau ci-dessous).Liste des extra-caractères les plus couramment utilisés à l’intérieur d’une chaîne de caractères :

Une liste permet de lister différents objets qui peuvent être de tout type. Elle apparaît comme une succession d’objets compris entre crochets et séparés par des virgules. On peut donc placer dans des listes du texte, des nombres, des images ou même des listes comme on le verra plus tard.

l=[ 4, 'texte', 11.2, chien, 7/3, 7//3, '3.2', changer] 
print("Le contenu de la liste l : ", l)
print("Le type de l : ", type(l) )

for i,x in enumerate(l) :
	print( "Valeur de l[{}] : {}.".format(i,x) )
	print( "Type de l[{}] : {}.".format(i,type(x)) )

Le contenu de la liste l :  [4, 'texte', 11.2, 'chien', 2.3333333333333335, 2, '3.2', 'changer']
Le type de l :  <class 'list'>
Valeur de l[0] : 4.
Type de l[0] : <class 'int'>.
Valeur de l[1] : texte.
Type de l[1] : <class 'str'>.
Valeur de l[2] : 11.2.
Type de l[2] : <class 'float'>.
Valeur de l[3] : chien.
Type de l[3] : <class 'str'>.
Valeur de l[4] : 2.3333333333333335.
Type de l[4] : <class 'float'>.
Valeur de l[5] : 2.
Type de l[5] : <class 'int'>.
Valeur de l[6] : 3.2.
Type de l[6] : <class 'str'>.
Valeur de l[7] : changer.
Type de l[7] : <class 'str'>.

Passage d'une liste à une chaîne et réciproquement.

Il est parfois utile de passer d'une liste à une chaîne, d'une chaîne à une liste.

On consultera notamment les fonctions join et split :

• sur "Dive into python"
• join et split

def f(x) : return 5x+4

g=lambda x:x**2


Listef=[ f(k) for k in range(5)]
print("Liste d'images par f : ", Listef)

Listeg=[ g(k) for k in range(5)]
print("Liste d'images par g : ", Listeg)

print('Type de f : ', type(f) )
print('Type de g : ', type(g) )

Liste d'images par f :  [4, 9, 14, 19, 24]
Liste d'images par g :  [0, 1, 4, 9, 16]
Type de f :  class 'function'
Type de g :  class 'function'

Les tuples sont un tableau d’objets qui peuvent être de tout type. Ils ne sont pas modifiables.

Un tuple apparaît comme une liste d’objets comprise entre parenthèses et séparés par des virgules. Leur création reprend le même format :

Remarque

x = (4,5) 		# création d’un T-uple composé de 2 entiers
y = ("un",1,"deux",2) 	# création d’un T-uple composé de 2 chaînes de caractères
# et de 2 entiers, l’ordre d’écriture est important.
z = (3,) 		# création d’un T-uple d’un élément, sans la virgule, le résultat est un entier

la valeur de x :  (4, 5)
le type de x : <class 'tuple'>
la valeur de y :  ('un', 1, 'deux', 2)
le type de y : <class 'tuple'>
la valeur de z :  (3,)
le type de z : <class 'tuple'>

Un exemple parmi les nombreux intérêts de ce type : pouvoir retourner plusieurs valeurs par une fonction.

Exemple : la division euclidienne :

def divEucl(a,b):
	""" a et b sont deux entiers naturels, b non nul.
	divEucl retourne le quotient et le reste dans la division de a par b
	sous forme d'un tuple."""
	q=0
	while a >= b :
		a-=b
		q+=1
	return (q, a)


a=231
b=13
quotient, reste = divEucl(a,b)

print(quotient)
print(reste)

17
10

Les dictionnaires sont des listes de couples. Chaque couple contient une clé et une valeur. Chaque valeur est indicée par sa clé. La valeur peut-être de tout type, la clé ne doit être ni une liste, ni un dictionnaire. Chaque clé comme chaque valeur peut avoir un type différent des autres clés ou valeurs.

Un dictionnaire apparaît comme une succession de couples d’objets comprise entre accolades et séparés par des virgules. La clé et sa valeur sont séparées par le symbole : . Leur création reprend le même format :

Exemple >

d={ 'Henry' : '06 23 56 45 78', 'Léa' : '06 56 45 32 76', 'Elias' : '06 36 56 45 48' }

print('Le type de d : ', type(d))

for x in d :
	print("Nom de l'élève : {}. n° de tél de {} : {}.".format(x, x, d[x]))
	
	
print("Ajout d'un élément.")
d['Sandra']='06 66 65 23 12'
print(d)

On obtient :

Le type de a :  Le type de d :  <class 'dict'>
Nom de l'élève : Elias. n° de tél de Elias : 06 36 56 45 48.
Nom de l'élève : Léa. n° de tél de Léa : 06 56 45 32 76.
Nom de l'élève : Henry. n° de tél de Henry : 06 23 56 45 78.
Ajout d'un élément.
{'Sandra': '06 66 65 23 12', 'Elias': '06 36 56 45 48', 'léa': '06 56 45 32 76', 'Henry': '06 23 56 45 78'}

On remarquera que l'ordre d'affichage n'est pas nécessairement l'ordre de définition. Il n'y a en fait pas d'ordre dans les éléments d'un dictionnaire.

Pour en savoir plus sur les dictionnaires, on pourra consulter le cours de G.Swinnen.

Utilisation des modules en Python

On sait à présent utiliser quelques instructions de base en Python. Cependant, il arrivera qu'on ait besoin d'autres fonctions. Elles sont regroupées par module que l'ont peut importer au fur et à mesure.

Par exemple le module de math permet d'utiliser des fonctions mathématiques.

Il existe deux façon d'utiliser un module :

Soit on importe tout et on peut utiliser les fonctions normalement :

from math import *
print("la racine carrée de 3 est : ", sqrt(3))
print("la partie entière de 13.945 est : ", floor(13.945))

Ce qui affiche :

la racine carrée de 3 est :  1.7320508075688772
la partie entière de 13.945 est :  13

Remarque

Attention sans l'instruction :

from math import *

le programme:

print("la racine carrée de 3 est : ", sqrt(3))
print("la partie entière de 13.945 est : ", floor(13.945))

ne fonctionne pas car on ne reconnaît pas les fonctions :

sqrt()
floor()

Le programme ne s'exécute pas et on obitent le message :

NameError: name 'sqrt' is not defined

Soit on importe le module de la manière suivante :

import math
print("la racine carrée de 3 est : ", math.sqrt(3))
print("la partie entière de 13.945 est : ", math.floor(13.945))

Ce qui affiche :

la racine carrée de 3 est :  1.7320508075688772
la partie entière de 13.945 est :  13

Remarque

De même, sans l'instruction :

import math

le programme:

print("la racine carrée de 3 est : ", math.sqrt(3))
print("la partie entière de 13.945 est : ", math.floor(13.945))

ne fonctionne pas car on ne reconnaît pas les fonctions :

math.sqrt()
math.floor()

Le programme ne s'exécute pas et on obitent le message :

NameError: name 'math' is not defined

Soit on importe que les fonctions du module dont on a besoin :

from math import sqrt, floor
print("la racine carrée de 3 est : ", sqrt(3))
print("la partie entière de 13.945 est : ", floor(13.945))

Ce qui affiche :

la racine carrée de 3 est :  1.7320508075688772
la partie entière de 13.945 est :  13