Les types simples, tels que les entiers (int), les flottants (float), les chaine de caractères (str), ou les booléens (bool), permettent de stocker une valeur en mémoire.
Pour stocker plusieurs valeurs, on peut utiliser plusieurs variables. Mais cela peut vite devenir fastidieux et particulièrement compliqué si on a un grand nombre de valeurs ou si leur nombre est arbitraire.
Pour cela, on constitue à partir des types de base des types construits. Python dispose de plusieurs types construits, pour des usages différents.
Ce sont les types liste, tuple, tableau, et dictionnaire :
Python dispose de plusieurs type pour gérer des ensembles de données, constantes comme variables, et potentiellement de différents types. Ce sont de véritables couteaux Suisses que l'on peut utiliser dans tous les domaines de l'informatique. Ici nous ne faisons qu'une première présentation d'introduction à ces types : le minimum vital pour pouvoir les utiliser dans ce BN. Nous les retrouverons de fassons plus exhaustive et explicite dans les autres bloc-notes par domaine d'application...
Une liste en Python est un ensemble d'éléments, éventuellement de différents types, séparés par des virgules. Une liste se définit à l'aide des crochets et une liste vide est symbolisée par [].
L'accès à un élément de la liste se fait en donnant son index :
ma_liste=[3.14, "cours NSI", True, 5]
ma_liste[1], type(ma_liste)
Pour ajouter un élément à une liste on peut utiliser la méthode append()
ma_liste.append("toto")
ma_liste
Le type list possède de nombreuses autres méthodes...
help("list")
ma_liste.pop()
ma_liste
On peut parcourir les éléments d'une liste
for item in ma_liste :
print(item)
On peut modifier un élément en particulier :
ma_liste[1]="titi"
ma_liste
L'appel de la fonction len(liste) renvoie la taille de liste
len(ma_liste)
Ce qui permet de faire un parcours par les indices
for indice in range(len(ma_liste)) :
print(ma_liste[indice])
En Français, on dit n-uplets, p-uplets, k-uplets ou encore t-uplets...
Les tuples sont des listes particulières, on ne peux pas les modifier.
Ils sont définis par des parenthèses et leurs éléments, séparés par des virgules, sont accessibles de la même manière que pour les listes ou les chaines.
Pour lever toute ambiguïté, un tuple ne contenant qu'un seul élément sera noté (element,).
monTuple=(3.14, "cours NSI", True, 5)
monTuple[1], type(monTuple)
On ne peut pas modifier un tuple, on dit qu'il est non mutable :
monTuple[1]="toto"
monTuple
On peut convertir une liste en tuple :
monNouveauTuple = tuple(maListe)
monNouveauTuple, type(monNouveauTuple)
Et inversement, un tuple en liste :
maNouvelleListe = list(monTuple)
maNouvelleListe, type(maNouvelleListe)
Les tuples permettent d'effectuer plusieurs affectations en une seule ligne
(a, b) = (2, "toto")
a
b
Les tuples permettent de permuter les valeurs de deux variables :
(a, b) = (b, a)
a
b
Les tuples permettent de renvoyer plusieures valeurs dans un même ensemble (les parantèses ne sont pas obligatoires)
a, type(a), b, type(b)
Ce qui est pratique dans une fonction :
def foo(x,y) :
return x+y,x-y,x*y,x//y,x%y,x/y
foo(10,3)
type(foo(10,3))
Un dictionnaire est une liste où l'accès aux éléments se fait à l'aide d'une clé alphanumérique ou purement numérique. Il s'agit d'une association clé/valeur sous la forme clé:valeur.
Les dictionnaires sont définis a l'aide des accolades.
monDictionnaire = {'zero':0, 'un':1, 'deux':2,'trois':3}
monDictionnaire['zero'], type(monDictionnaire)
Les tableaux sont en général des listes de listes pas obligatoirement homogène en taille, ni en type :
monTableau= [[1,2,3,4],["toto","titi","tata"], [-3.14, 0.5, 1, 2.35, 6.48]]
monTableau[1][0], type(monTableau)
La bibliothèque
numpypermet de gérer des tableaux numériques homogènes, des matrices...
Rechercher d'autres types construits du langage Python...
| Contenus | Capacités attendues | Commentaires |
|---|---|---|
| p-uplets. p-uplets nommés |
Écrire une fonction renvoyant un p-uplet de valeurs. | |
| Tableau indexé, tableau donné en compréhension |
Lire et modifier les éléments d’un tableau grâce à leurs index. Construire un tableau par compréhension. Utiliser des tableaux de tableaux pour représenter des matrices : notation a [i] [j]. Itérer sur les éléments d’un tableau. | Seuls les tableaux dont les éléments sont du même type sont présentés. Aucune connaissance des tranches (slices) n’est exigible. L’aspect dynamique des tableaux de Python n’est pas évoqué. Python identifie listes et tableaux. Il n’est pas fait référence aux tableaux de la bibliothèque NumPy. |
| Dictionnaires par clés et valeurs | Construire une entrée de dictionnaire. Itérer sur les éléments d’un dictionnaire. | Il est possible de présenter les données EXIF d’une image sous la forme d’un enregistrement. En Python, les p-uplets nommés sont implémentés par des dictionnaires. Utiliser les méthodes keys(), values () et items (). |