1ereNSI/representation_construits/chapitre_1/.ipynb_checkpoints/README-checkpoint.ipynb

Représentation des données : tuples, listes et itérations

Contenue : Notions introduites : le type conteneur, avec les listes, les tuples, parcours de séquences.

Compétences : Comprendre la différence entre une liste python et un tuple. Maîtriser la création de conteneurs sur Python.

Le programme

---

Apport de connaissances

---

Les types conteneurs comme les tuples ou les listes permettent de stocker des objets, et proposent des méthodes d'accès, de modification et d'itération sur ces mêmes objets.

Ici nous allons voir trois types de conteneurs en particulier : les tuples, les listes, et enfin les dictionnaires. En apprenant à créer et à manipuler ces types d'objets, cela nous permettra de travailler sur un grand nombre de données de manière rapide et efficace.

---

Les listes

Pour le moment, nous n'avons appris à travailler qu'avec un nombre limité de variables. Cependant, il peut arriver que vous deviez lire, stocker, traiter et enfin imprimer des dizaines, voire des centaines ou des milliers de valeurs de données. Comment stocker et accéder efficacement à ces données ?

Par exemple, si l'on décide de de manipuler une demi-douzaine de variables, doit on les déclarer comme ceci :

var1 = int(input()) var2 = int(input()) var3 = int(input()) var4 = int(input()) var5 = int(input()) var6 = int(input())

Nous allons voir qu'avec une liste, nous allons pouvoir déclarer une variable à valeurs multiples.

---

Créer une liste

Créer une liste vide :

In [ ]:

nom_liste = []

On peut les créer par extension (comprendre liste déclarée littéralement) comme ceci :

In [ ]:

nom_liste = [3, 8, 5, 4]

Mais aussi par compréhension (itération, que l'on verra plus loin)

On peut tester ça dans la console python

In [ ]:

lst = [2, 3, 5, 7 ]

In [ ]:

type (lst)

On peut afficher la liste de la même manière qu'une variable classique : avec la commande print

In [ ]:

print (lst)

---

Accéder aux élèments d'une liste

Les élèments d'une liste peuvent être comparé à des élèments d'une séquence : chaque élèment a une position précise dans la liste, comme nous l'avons vu pour les chaînes de caractères (str)

On appelle cette position indice, c'est cet indice qui nous permet d'accéder à un élèment en particulier.

Le premier élèment d'une liste a pour indice 0

Tout comme avec les chaînes de caractères, un indice négatif permet d'accéder l'élèment en partant de la fin

Pour connaître le nombre total d'élèments dans une liste, on utilise la fonction len

In [ ]:

lst = [2,4,6,8]
len (lst)

On peut désigner une tranche en indiquant l'indice du premier élèment, ainsi que celui du dernier non inclus

In [ ]:

lst [1:3]

Attention : Un indice qui dépasse la valeur longueur de la liste - 1 provoquera une erreur dans votre code

---

Parcours d'une liste

Comme indiqué plus haut, il est possible de créer et de parcourir une liste par une méthode dite de compréhension ou itération

Celà signifie qu'on construit une liste à partir d'élèments itérables : que l'on peut répétèr. Par exemple :

In [ ]:

liste = [x for x in range(5)]
print(liste)

Que vous affiche la console ?

L'intérêt des listes par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...

On peut également initialiser une liste à partir d'une autre liste

In [ ]:

liste = [1, 2, 3, 4]
nouvelle_liste = [2 * x for x in liste]
print(nouvelle_liste)

Une fois que la liste est crée, on peut la parcourir :

In [ ]:

for elt in lst:
    print (elt, end='')

Ici, on va afficher chaque élèment de la liste lst

On peut également utiliser une boucle en itérant l'indice i des élèments :

In [ ]:

for i in range (len(lst)):
    print(lst[i], end='')

Ici, pour i compris entre 0 et longueur de lst, on va affichier l'élèment correspondant à l'indice valant i.

À faire :

• créer une liste par extension, puis par itération
• afficher les élèments d'une liste

---

Propriétés d'une liste

Une liste peut être modifiable : on parle d'un objet mutable

• On peut donc supprimer un élèment d'une liste avec le mot clé del

In [ ]:

lst = [1,2,3,4,5]
del lst[0]
print(lst)

Il faut noter qu'en supprimant l'élèment situé à l'indice 0, j'ai donc fait changer tous les indices des élèments de la liste ! On peut également ajouter un élèment à la liste :

In [ ]:

lst = [1,2,3,4,5]
lst.append(6)
print (lst)

L'élèment ajouté se positionne donc à la fin de la liste

Pour modifier un élèment en particulier, on lui affecte une nouvelle valeur :

In [ ]:

lst = [1,2,3,4,5]
lst[1] = 8
print (lst)

Il est préférable de ne stocker que des données de même type dans une liste

Une liste peut être passée comme paramètre d'une fonction

---

Les tuples (ou p-uplets)

À la différence des listes, les tuples ne sont pas mutables. On ne peut donc plus les modifier une fois créés, leur taille est fixe.

Mais ils peuvent néanmoins contenir des données de différents types.

Pour initialiser un tuple, on utilise cette syntaxe :

In [ ]:

tuple = (1, 3)
print (tuple)

Ici, de la même manière que les listes, on pourra accéder à un élèment en particulier via son indice

In [ ]:

tuple = (1, 3, 5, 7, 9)
tuple[-1]

De plus, on peut tout à fait utiliser l'itération pour construire ou parcourir une structure tuple.

Enfin, il est courant, dans une fonction, de renvoyer plusieurs valeurs. Par exemple, via ce type de syntaxe :

In [ ]:

return a, b

En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple composé des variables a et b qui est renvoyé.

---

À retenir:

Pour les listes et tuples :

Opération	Résultat
x in t	Renvoie True si un élément de t est égal à x
x not in t	Renvoie True si aucun élément de t n'est égal à x, False sinon
len(t)	Renvoie le nombre d'éléments de t
t == t1	Renvoie True si t et t1 sont de même type, ont la même longueur, et ont des éléments égaux 2 à 2

Opération	Résultat
t[i]	Renvoie l'élément d'indice i de t
t[i:j]	Renvoie une partie de t de l'indice i à j non inclus
t.index(x)	Renvoie l'indice de la première apparition de x dans t
t.count(x)	Renvoie le nombre d'apparitions de x dans t
s + t	Renvoie une nouvelle séquence qui correspond à la concaténation de s et de t (seulement si s et t ont le même type

Uniquement pour les listes :

Opération	Résultat
l.append(x)	Ajoute l'élément x à la fin de la liste l
l[i] = x	Modifie la liste et affecte la valeur x à la case d'indice i
l.insert(i, x)	Insère l'élément x dans la liste l à la position de l'indice i
l.remove(x)	Supprime de la liste le premier élément dont la valeur est égale à x
l.pop(i)	Enlève de la liste l'élément à la position i et renvoie sa valeur