Introduction aux listes

Tu as pu apprendre grâce au TP précédent à faire ton premier programme, notamment avec l’utilisation de variables.

Nous allons voir dans ce TP d’autres types de valeurs que peut contenir une variable.

En effet, une variable peut contenir toutes sortes de valeurs, tu as déjà vu :

• les entiers : pommes = 10
• les chaînes de caractères : stage = "GCC!"

Et quelques opérations en utilisant ces variables.

Ici, nous allons parler des listes.

Une liste est un type qui permet de stocker plusieurs éléments.

Par exemple :

La liste dans la variable ma_liste est composée de 3 entiers : 1, 2 et 3.

On peut accéder directement à un élément d’une liste si on connaît sa position (son index) avec l’opérateur [].

L’index des éléments dans une liste commencent à 0 :

On peut également modifier les éléments de la liste, si on connaît leur position. Par exemple:

Maintenant qu’on sait comment utiliser simplement une liste, accéder et modifier ses éléments, on va pouvoir faire des opérations dessus, comme ajouter et supprimer des éléments, dans la prochaine section.

Opérations sur les listes

Nous avons vu dans la section précédente comment créer une liste avec des valeurs, et y accéder.

Sauf qu’une liste, si elle est fixe, elle nous sert pas à grand chose. Nous on veut pouvoir la modifier, comme ajouter des éléments par exemple !

Ajout dans une liste

Il existe plusieurs manières d’ajouter un élément dans une liste, nous allons commencer avec la méthode append.

Append

Revenons à notre ajout d’éléments dans une liste, la méthode append nous permet d’ajouter un élément à la fin d’une liste :

Il est également possible de créer une liste vide, donc qui ne possède pas d’éléments, et de lui en ajouter plus tard.

Insert

Il existe une 2e méthode pour ajouter un élément dans une liste, la méthode insert.

Celle-ci permet d’ajouter un élément à la position (à l’index) qu’on veut dans la liste.

Suppression dans une liste

Les ajouts c’est bien beau, mais si on ne peut jamais supprimer des éléments, on va vite être débordé !

Comme pour l’ajout, il existe plusieurs manières de supprimer un élément dans une liste, nous allons commencer avec la méthode pop.

Pop

La méthode pop permet de supprimer un élément d’une liste.

Il existe plusieurs manières de l’utiliser :

Lorsque nous utilisons pop sans paramètre, nous supprimons le dernier élément de la liste.

Mais si on lui donne un paramètre, on supprime l’élément qui se trouve à l’index donné :

Remove

La 2e méthode pour supprimer des éléments dans une liste est remove. Celle-ci permet de supprimer un élément en le cherchant dans la liste.

Félicitations ! Tu sais maintenant utiliser les listes avec la plupart de leurs méthodes.

Passe à la section suivante pour apprendre d’autres opérations sur les listes.

Autres opérations sur les listes

Nous avons précédemment utilisé l’ajout et la suppresion d’éléments dans une liste. On a également vu comment avoir le nombre d’éléments (la longueur) d’une liste avec la fonction len.

Voici d’autres opérations utiles sur les listes.

in : appartenance d’un élément à une liste

Le mot-clé in (“dans” en français) permet de tester si un élément est présent dans une liste.

Revenons au mot-clé in, il s’utilise comme suit :

Parcourir tous les éléments d’une liste à l’aide d’une boucle

Il est parfois pratique d’accéder à tous les éléments d’une liste de la même manière.

Pour être plus efficace et ne pas avoir à copier coller plusieurs fois la même chose, nous pouvons utiliser une boucle.

Par exemple :

Nous avons une liste avec 4 morceaux de phrase (les paroles d’une belle chanson d’ailleurs).

La ligne for variable in ma_liste: se lit “Pour toute variable dans la liste ma_liste”, on aurait pu changer le nom de variable en parole, puisqu’il prend la valeur des éléments de la liste au fur et à mesure.

La première fois que le programme passe sur la ligne de la boucle (for variable in ma_liste:), variable prend la valeur du 1er élément de la liste : “Emmenez-moi au bout de la terre”.

Ensuite le programme exécute le bloc de la boucle avec cette valeur, donc affiche variable puis affiche “…”.

Le bloc de boucle est fini, le programme revient sur la ligne for variable in ma_liste:. variable prend ainsi la 2e valeur de la liste : “Emmenez-moi au pays des merveilles”, et il exécute le bloc de la boucle avec cette valeur.

De même pour les 2 autres éléments de la liste.

Après avoir exécuté la boucle pour les 4 (tous) éléments, le programme revient sur la ligne for variable in ma_liste:. Il n’y a plus d’éléments dans la liste sur lesquels on n’est pas passé, donc on sort de la boucle.

Et on affiche “– Applaudissements –”

Nous avons vu que les listes pouvaient contenir plusieurs types. Peu importe ce que contient la liste, le parcours des éléments de celle-ci sera identique :

Il existe une 2e méthode de parcours des éléments d’une liste, qui utilise le moyen d’accéder aux éléments d’une liste vu précédemment.

Il s’agit d’une boucle for également, mais qui va passer sur les index, au lieu des éléments directement :

Cette méthode utilise plusieurs éléments vu précédemment :

• calcul de la longueur de la liste (son nombre d’éléments)
• boucle for avec un range (vu dans le TP précédent)
• l’accès à une valeur dans la liste en utilisant les [] avec un index

Si on exécute ce code pas à pas, ça donnerait :

• len(ma_liste) -> 5
• for i in range(5): -> on répète 5 fois une action, avec la variable i qui commence à 0 et qui augmente de 1 à chaque tour de boucle
• ma_liste[i] -> accès à l’élément à l’index i dans la liste ma_liste
• print(ma_liste[i]) -> affiche cette valeur

Le principal avantage de cette méthode est l’accès à l’index des éléments au fur et à mesure, donc il est également possible d’utiliser cet index, pour un calcul, ou la modification de l’élément dans la liste.

Autres opérations sur les listes : concaténer des listes

Concaténer deux listes avec l’opérateur +

En Python, on peut aussi concaténer deux listes, c’est-à-dire les mettre l’une à la suite de l’autre pour n’en créer qu’une.

Pour ce faire, on utilise l’opérateur +.

Par exemple, on crée deux listes liste1 et liste2, on les fusionne dans une troisième liste liste3, puis on affiche liste3 :

Ce code affiche [10, 20, 30, 4, 5, 6, 7, 8].

Il est possible d’utiliser + sur plus de 2 listes, par exemple :

Cet opérateur nous permet d’être plus rapide lors d’opérations spécifiques, comme le test d’appartenance d’un élément sur plusieurs listes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

sac_eleve1 = ["cahier", "trousse", "livre"]
trousse_eleve1 = ["feutre", "crayon", "gomme", "stylo rouge"]

sac_eleve2 = ["cahier", "trousse", "livre", "telephone"]
trousse_eleve2 = ["effaceur", "crayon", "stabilo", "stylo bleu"]

sac_eleve3 = ["cahier", "trousse"]
trousse_eleve3 = ["craie", "crayon", "gomme", "stylo noir"]

sac_eleve4 = ["cahier", "trousse", "livre"]
trousse_eleve4 = ["crayon", "stylo bleu"]

sac_eleve5 = ["cahier"]
trousse_eleve5 = []

Concaténer plusieurs fois la même liste avec l’opérateur *

Imaginons maintenant qu’on veuille créer une liste remplie de 42, disons 100 fois le nombre 42 :

C’est un opérateur rapide, qui est très utile lorsqu’on doit gérer une liste de taille donnée au départ.

Projet : le 21

Après tous ces cours et exercices, on est plutôt à l’aise sur les listes et leur utilisation.

Vient maintenant l’heure de s’amuser avec un projet : le 21 !

Le 21 est un jeu de cartes qui consiste à jouer contre la banque. Le but ? Obtenir un score supérieur à celui du banquier sans dépasser le score de 21.

L’objectif ultime étant de parvenir à 21 points avec seulement deux cartes : un as et un roi, un as et une reine, un as et un valet ou un as et un 10. C’est cette combinaison gagnante.

Jeu de cartes

Le 21 peut se jouer avec un ou plusieurs paquets de 52 cartes. Les casinos, pour éviter la triche, ou le comptage de cartes, jouent avec plusieurs paquets. Le 21 peut se jouer avec un ou plusieurs paquets de 52 cartes. Nous allons ici jouer avec un seul paquet.

Donc la première étape de notre jeu est de définir le paquet de cartes utilisé. Un paquet de 52 cartes est réparti en 4 couleurs : trèfle, coeur, pique, carreau ; avec des cartes allant de 2 à 10, puis le Valet, la Dame, le Roi, et l’As.

Pour définir une carte dans notre jeu, avec sa couleur et son nom, nous la représenterons sous forme de tuple (un couple de valeur)

Pour accéder aux valeurs contenues dans un couple, on peut utiliser l’opérateur [] :

Ainsi, nous pouvons créer notre “jeu”, notre deck de cartes : une liste de cartes, donc une liste de couples.

Les noms des cartes : 2, 3, 4, 5, 6, 7, 8, 9, 10, Valet, Dame, Roi, As

Les couleurs des cartes : Trèfle, Coeur, Pique, Carreau

Valeur des cartes

Le 21 est un jeu avec un système de points. Chaque carte a son nombre de points.

Les cartes avec des nombres (2 à 10) ont un nombre de points égal à leur numéro.

Les cartes avec des figures (Valet, Dame, Roi) comptent chacune pour 10 points.

L’As compte pour 11 points. Dans certaines règles, il peut compter pour 1 point, mais nous allons pas l’appliquer dans notre jeu.

Pour accéder rapidement à la valeur des cartes dans notre jeu, nous allons créer une fonction qui, à partir d’une carte (un couple nom-couleur), retourne la valeur de la carte.

Pour notre jeu, nous allons créer la fonction valeur_carte(carte) qui à partir de la carte, nous donne son nombre de points.

Distribution des cartes

Le 21 est un jeu où le joueur affronte la banque. Il faut donc leur donner des cartes aux 2.

Nous allons créer une liste vide pour chacun, qui représentent leurs mains : main_joueur et main_banque.

Ensuite, nous mélangeons le paquet de cartes, le deck, avec la fonction random.shuffle(). Pour utiliser cette fonction, nous devons dire au programme de récupérer le module random qui contient plusieurs fonctions de générations d’aléatoire. La fonction shuffle() prend en paramètre une liste et la mélange.

Enfin, on retire 2 cartes du paquet, pour les mettre dans la main du joueur, et 2 autres cartes pour les mettre dans la main de la banque.

Pour finir, on affiche les cartes du joueur, et uniquement la 1ere carte de la banque (la 2nde doit rester cachée pour le bien du jeu).

Calcul du score du joueur

Il est possible d’aider le joueur pour son choix futur, en lui affichant le score actuel de sa main. En effet, il souhaitera piocher une nouvelle carte si son score est faible, mais garder ses 2 cartes si son score est élevé.

Pour cela, nous allons créer une variable score_joueur qui va être égale à la somme de la valeur de ses cartes (tu peux utiliser la fonction valeur_carte définie précédemment), et l’afficher.

21 !

Le jeu peut s’arrêter tout de suite si le joueur possède le graal entre ses mains : le 21 !

Comme dit dans l’introduction, le score optimal pour ce jeu est 21. Il est possible de faire un score de 21 au premier tirage avec un As, et une tête (Valet, Dame, Roi) ou un 10.

Le score étant déjà calculé dans la partie précédente, nous avons juste à comparer celui-ci à 21.

Si le joueur a effectivement un score de 21, nous le félicitons ! Sinon, le jeu continue, avec la prochaine section.

Choix du joueur

Toute la stratégie du jeu est dans cette partie.

Un joueur, ayant un score inférieur à 21, peut demander à la banque de rajouter une ou plusieurs cartes à sa main.

Mais attention ! Si la main du joueur dépasse le score de 21, celui-ci perd la partie.

Ainsi, nous allons demander au joueur ce qu’il souhaite faire, avec la fonction input (que l’on a revu dans la partie “Ajout” de ce TP).

Nous allons demander au joueur s’il veut tirer une carte ou ne rien faire, en répondant avec une seule lettre : “c” pour demander une carte, “r” pour ne rien faire.

Si le joueur demande une carte, de la même manière qu’en début de jeu, nous retirons une carte du paquet pour l’ajouter dans sa main. Nous affichons cette carte au joueur, et ajoutons sa valeur à la variable score_joueur, que nous pouvons aussi afficher.

Le score du joueur ayant changé, il est possible que celui-ci dépasse 21. Or 21 est la limite : il faut s’en approcher, sans jamais la dépasser.

Nous allons donc vérifier que le score du joueur n’excède pas 21. S’il dépasse, le jeu est fini et le joueur a perdu. Sinon, le joueur peut une nouvelle fois choisir s’il souhaite tirer une carte ou ne rien faire.

Vous pouvez utiliser une boucle pour répéter cette étape, tant que le joueur n’a pas perdu et qu’il demande une carte.

Tirage de la banque

Si le joueur est toujours dans la course contre la banque, c’est maintenant à celui-ci de tirer des cartes pour se rapprocher de 21.

Tout d’abord, nous dévoilons la carte restée inconnue du tout premier tirage.

Ensuite, nous calculons le score de la banque avec ses 2 cartes.

Le choix de la banque est simple : s’il a un score inférieur à 17, alors il tire une carte, ou plusieurs si même après un tirage il n’atteint pas à 17.

De même, tu peux utiliser une boucle pour le tirage des cartes de la banque.

Qui a gagné ?

Enfin, le moment de départager les 2 adversaires !

Si le joueur a un score supérieur à 21, comme dit précédemment, celui-ci perd la partie.

Si c’est la banque qui dépasse 21, alors c’est le joueur qui gagne !

Si les 2 adversaires sont encore en course, nous comparons les scores des participants :

• si le score du joueur est supérieur à celui de la banque, il gagne
• si le score du joueur est égal à celui de la banque, c’est une égalité
• si le score du joueur est inférieur à celui de la banque, il perd