Séquence

Nous avons manipulé des variables avec des types simples : int, bool, float, str. Ce sont des conteneurs ne contenant qu'une valeur.

Nous avons manipulé aussi, sans vraiment l'étudier, des types construits (ou types abstraits) : liste, tuple. Ces types de données s'appellent des séquences.

Dans ce cours nous allons étudier deux types de séquence : les tableaux et les p-uplets. En python, les tableaux s'appellent les listes et les p-uplets s'appellent les tuples.

Séquence

Une séquence est une famille d'éléments indexée par les entiers strictement positifs inférieurs ou égaux à un certain entier, ce dernier étant appelé longueur de la séquence.
Ce terme de séquence est à rapprocher du concept de suite en mathématiques.

En informatique, un tableau est une structure de données représentant une séquence finie d'éléments auxquels on peut accéder efficacement par leur position, ou indice, dans la séquence.
C'est un type de conteneur que l'on retrouve dans un grand nombre de langages de programmation.

En Python, une séquence est une collection ordonnée d’objets qui permet d’accéder à ses éléments par leur numéro de position dans la séquence. Les listes et les tuples sont des séquences.

Il y a des points communs et des différences entre ces deux types.

Le type construit p-uplet (tuple en python)

Définition

p-uplet, tuple en python

Un p-uplet est une séquence immutable, c'est-à-dire une suite indexée de valeurs (de n'importe quel type) que l'on ne peut pas modifier.

En Python, un p-uplet est de type tuple et est indexé à partir de 0.

Dans un jeu vidéo, vous voulez identifier des lieux précis.
Pour cela, vous associer à chaque lieu un triplet (nom,abscisse,ordonnée).
Ainsi, le château du joueur A pourra ainsi est modélisé par une séquence comme ("fort_1",15,-56.2).
Remarquez que les éléments du p-uplet sont de trois types différents ici.

Construire les objets tuple

Construire un objet tuple en python.

Un tuple est défini à l'aide de virgules et de parenthèses.

Les parenthèses sont nécessaires à la création d'un tuple vide pour le reste elle ne sont qu'une aide à la lecture.

L'utilisation de la virgule est nécessaire dès qu'on veut faire autre chose qu'un tuple vide.


tup1=()                 # un tuple vide
tup2=(3,)               # tuple avec un seul élément
tup3=(1,4,5,'moto',4.6) # tuple avec cinq élément 
tup4=1,4,5,'moto',4.6   # même tuple sans parenthèse

type(tup1)              # pour accéder au type de l'objet
print(tup3==tup4)       # test si les tuples tup3 et tup4 sont égaux ou non
			

Exécuter le script de l'exemple précédent.

Pour cela, vous pouvez utiliser votre IDE habituel (VSCode, Jupyter, Edupython, ...), mais vous avez aussi ci-dessous à disposition un "bac à sable" pour vos tests.
Il vous suffit de saisir le script puis de l'exécuter en cliquant sur "►RUN"

Il est important d'alimenter votre cahier de bord.

Code de déblocage de la correction :

Soient i un entier et t un tuple

On donne le tuple suivant : casse_all = ("chateauB",-10,48.2,False) qui signifie que que le lieu considéré est nommé "châteauB", qu'il se situe au point de coordonnées $(-10;48.2)$ et qu'il n'est pas occupé par le joueur B.

Écrire les lignes de code qui affichent :

  1. 48.2

  2. le dernier élément du tuple

  3. (-10,48.2)

  4. "chateauB"

Code de déblocage de la correction :

Chaque joueur peut possèder plusieurs personnages actifs, chacun se situant dans un lieu donné.
Stockons l'ensemble des lieux occupés par les personnages du joueur C au tour 8 dans le tuple C_tour8.

Suppososns que C_tour8 = (("antre_orcs",85,36),("chateau_C",-105.2,23,True))

Écrire les lignes de code qui affichent :

  1. "chateau_C",-105.2,23,True

  2. "chateau_C"

  3. -105.2,23

Code de déblocage de la correction :

Remarquer dans l'exemple précédent qu'un tuple peut en python contenir des éléments de différents types.
Certains éléments d'un tuple peuvent eux aussi être des tuples.

Un tuple est un objet immutable : on ne peut pas réaffecter ses éléments, supprimer un élément ou encore en ajouter.

Tester ces deux lignes de codes :

tup=(1,4,5,'moto',4.6)
tup[3]='vive le vélo !'

Code de déblocage de la correction :

Un tuple est itérable.
Cela signifie que l'on peut organiser une itération (boucle for) sur cette structure.

Tester les deux scripts suivant séparément :

tup=("puits_elfique",78,61.3)

for elt in tup :            # méthode 1, elt vaut tour à tour chaque élément de la séquence en respectant la position dans le tuple
	print(elt)              # print est utilisée à des fins d'observation de code ici : on lit le contenu de elt

for i in range(len(tup)):   # méthode 2, on parcourt les indices de la séquence
	print(tup[i])           # on lit le contenu de l'élément du tuple tup en position i

Code de déblocage de la correction :

Les opérations et les méthodes sur les tuples

Opérations/méthodes Description
Méthodes et opérations communes aux listes et tuples.
elt in tup Renvoie True si un élément de tup est égal à elt, False sinon
elt not in tup Renvoie True si aucun un élément de tup n'est égal à elt, False sinon
len(tup) Renvoie le nombre d'éléments de tup
tup == tup1 Renvoie True si tup et tup1 sont de même type, ont la même longueur et ont des éléments égaux deux à deux.
tup[i] Renvoie l'élément d'indice i de tup sachant que le premier élément a pour indice 0.
tup[i:j] Renvoie une partie de l'indice i à j, j étant non inclus
tup.index(elt) Renvoie l'indice de la première apparition de elt dans tup
tup.count(elt) Renvoie le nombre d'apparitions de elt dans tup
tup1+tup2 Renvoie une nouvelle séquence, séquence correspondant à la concaténation de tup1 suivie de tup2.
tup*n Renvoie une nouvelle séquence composée de la concaténation de tup avec lui même $n$ fois.

Voici deux tuples ci-dessous.

jours_1=('lundi','mardi','mercredi','jeudi','vendredi')
jours_2=('samedi','dimanche')

Utiliser les méthodes et les opérations du tableau pour tester les différentes questions :

  1. Tester si samedi est un élément de jours_1.

  2. Donner la longueur de jours_2.

  3. Tester si jours_1 est égal à jours_2.

  4. Donner le deuxième élément de jours_1.

  5. Donner la partie de jours_1 entre le deuxième élément et le quatrième élément.

  6. renvoyer l'indice de dimanche dans jours_2.

  7. Renvoyer le nombre de samedi dans jours_2.

  8. Créer un tuple semaine par concaténation de jours_1 et de jours_2.

Vous pouvez utiliser directement ce bac à sable, si vous voulez :

Code de déblocage de la correction :

exercice de renforcement

En utilisant un parcours de tuple avec la présence d'un indice, écrire une fonction est_dans(element,tple) qui en argument reçoit un entier element et un tuple d'entiers tple, fonction qui renvoie un booleen indiquant la présence ou non de element dans tple.

on testera la fonction au moins avec les scripts suivants :

Code de déblocage de la correction :

exercice de renforcement

Tuple et fonction

En Python, une fonction qui renvoie plusieurs éléments, comme par exemple avec return a,b,c, renvoie un tuple.

def milieu(xA,yA,xB,yB) -> tuple:
	"Formule qui renvoie les coordonnées du milieu d'un segment"
	return (xA+xB)/2, (yA+yB)/2

type(milieu(1,3,-1,2))

En utilisant milieu(1,3,-1,2), comment afficher seulement l'abscisse ? L'ordonnée ?

Code de déblocage de la correction :

Écrire une fonction triangle_rect(n) qui renvoie un tuple où chaque élément est un tuple de longueur trois, ces tuples sont constitués de trois entiers a, b,c tels que $0<a\leq b\leq c < n$ et le triangle de cotés $a$, $b$ et $c$ soit rectangle. Le tuple renvoyé doit contenir tous les triplets possibles.

Par exemple triangle_rect(20) renvoie le tuple ((3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15)).

Vous pouvez commencer par créer une première fonction est_rectangle qui prend en paramètre un tuple à trois éléments (a,b,c) et renvoie True si le triangle dont plus grand côté a pour longueur c est rectangle mais False sinon.

Code de déblocage de la correction :

Le type construit tableau (liste en python)

Définition

Tableau

Un tableau est une séquence mutable.

type list en Python

Une liste en Python est une séquence mutable de longueur variable et indexée à partir de 0.

Nous avons déjà rencontré la notion de tableau en javascript avec la commande array.

Construire les objets list

Une liste est définie à l'aide de crochets.

Pour initialiser en mémoire une liste nommée l et vide on écrira : l=[].

Une liste est un objet mutable : on peut réaffecter ses éléments, ou en ajouter.

  1. Pour modifier l'élément en position pos de la liste lst afin qu'il prenne la valeur valeur, il suffit d'utiliser une réaffectation en saisissant : lst[pos] = valeur.

  2. La méthode append permet d'ajouter à la fin d'une liste existante lst un élément element_a_ajouter. On écrira : lst.append(element_a_ajouter).
    On parle alors de création en extension (puisque la liste est ainsi étendue).

  1. Tester les exemples suivants :

    #1. Éxécuter le code suivant :
    liste=[1,4,9,7,"moto",4.5]
    print("liste avant ajout",liste)    # print est utilisée à des fins d'observation de code
    liste.append(35)                    # Ajout d'un élément à la fin de la liste
    print("liste après ajout",liste)    # print est utilisée à des fins d'observation de code
    
    liste[2]= 5                         # Modification de l'élément d'indice 2
    print("liste après modification",liste) # print est utilisée à des fins d'observation de code
    
  2. Reprendre le script précédent en remplaçant la liste liste par le tuple suivant :

    tup=(1,4,9,7,"moto",4.5)

    Attention ! Vous allez rencontrer des messages d'erreur avec les tuples.

Code de déblocage de la correction :

Une liste est aussi un objet itérable.
Cela signifie que l'on peut organiser une itération (boucle for ) sur cette structure.

La liste de points obtenus à un jeu est stockée dans une liste points.

Suite à une bonification, chaque point obtenu est doublé : la liste points doit donc être modifiée.

  1. Pour répondre à ce problème concret, proposer une fonction doubler qui prend en paramètre une liste et qui renvoie la liste où tous les valeurs ont été doublées.

    • Accéder aux éléments d'une liste lst à l'aide de crochets : lst[index] permet d'obtenir l'élément de la liste lst se trouvant en position indéxée par index,

    • Balayer successivement l'ensemble des éléments d'une liste lst avec for i in range(len(lst)): ou avec for elt in lst:.

  2. Tester la fonction créée.

Code de déblocage de la correction :

exercice de renforcement

Une entreprise décide d'augmenter le salaire annuel de 3% et d'octroyer une prime d'intéressement de 450€ à chacun de ses employés en fin d'année.

L'ensemble des salaires annuels de l'année précédente est implémenté par une liste salaires.

  1. Compléter la phrase suivante en précisant l'opération mathématique traduisant l'augmentation en pourcentage :
    Augmenter de 3% revient à ....

  2. Proposer une fonction augmenter qui prend en paramètre une liste stockant des nombres représentant des salaires, qui effectue les deux augmentations prévues sur les salaires annuels et qui renvoie la liste des salaires annuels après augmentation.

  3. Tester la fonction créée.
    Vérifier par exemple que augmenter([1850,2453,1978,3012,2106] renvoie [2355.5, 2976.59, 2487.34, 3552.36, 2619.18].

Code de déblocage de la correction :

Vous avez obtenu un ensemble de notes, ensemble implémentés sour forme d'une liste.
Par exemple, si vous avez obtenu comme note 12, 8, 13, 9 et 16, l'ensemble des notes est implémenté par la liste [12,8,13,9,16].

Vous aimeriez que seules les notes au-dessus de 10 soient prises en compte.
Pour cela, vous allez construire une fonction elager qui prend en paramètre une liste (de notes), crée une liste vide, puis ajoute à cette liste vide l'ensemble des notes au-dessus de 10 de la liste saisie en paramètre. Cette fontion elager renvoie finalement cette liste créée de notes au-dessus de 10.

Code de déblocage de la correction :

Le Delta encoding (ou codage par différence en français) est une des techniques pour compresser un tableau de valeurs.
Plutôt que de stocker la valeur elle-même, on stocke sa différence avec la valeur précédente.
Ainsi, lorsque les valeurs sont grandes, mais varient peu, les différences sont petites si bien que moins de bits sont nécessaires pour représenter en mémoire ces nombres.

Supposons, par exemple, la liste des salaires d'une entreprise suivant : salaires = [1745,1685,1701,1796,1864,1825].
Plutôt que de stocker cette liste, il suffit de stocker la liste salaires_delta= [1745,-60,16,95,68,-39].

  1. Écrire une fonction delta prenant en paramètre une liste de nombres et renvoyant la liste obtenue par le codage par différence.

  2. Tester la fonction écrite, par exemple avec la liste salaires = [1745,1685,1701,1796,1864,1825].

Code de déblocage de la correction :

exercice de renforcement

Pour ajouter un élément elt en fin d'une liste liste, on peut aussi effectuer la concaténation avec :

liste2 = liste+[elt]

La différence ici avec la méthode append est que la concaténation conduit à la création d'une nouvelle liste, tandis que la méthode append modifie la liste initiale sans en créer de nouvelle (rien n'est renvoyé).

Vous pouvez visualiser la différence avec cet exemple :

liste1 = [3,8,"mot",True]
liste2 = liste1 + ["qu'ont 4 N ?"]
print("liste1 :",liste1)
print("liste2 :",liste2)
liste1.append(3.14)
print("liste1 :",liste1)
print("liste2 :",liste2)
liste3 = liste1.append("pi")
print("liste1 :",liste1)
print("liste3 :",liste3)

Création en compréhension

Pour un jeu vidéo, le personne principal voit son niveau général augmenter de 1 dès que son nombre de points d'expérience atteint le carré d'un nombre entier. Par exemple, le personnage débutant commence avec un niveau de 0 lorsqu'il a 0 point d'expérience, il passe à 1 lorsqu'il atteint son premier point et reste à ce niveau jusqu'à l'obtention du quatrième point d'expérience où son niveau passe à 2 et ainsi de suite.
Pour gérer le lien entre niveau général du personnage et nombre de points d'expérience à obtenir pour le changement de niveau, vous décidez d'utiliser une liste lien où les valeurs sont les carrés des positions ; ainsi, l'index est le niveau général et la valeur associée est le nombre de points d'expérience nécessaire pour atteindre ce niveau.
Si vous limitiez le niveau maximal à 4, votre liste serait lien = [0,1,4,9,16].
Comme vous voulez dans un premier temps proposer un niveau maximal de 100, la liste lien contient 101 valeurs.
Plutôt que de saisir l'ensemble des valeurs directement, vous avez pensé utiliser une création par extension : partir d'une liste vide et rajouter à sa fin un carré jusqu'au carré de 100, comme le script suivant :

lien = []       # liste vide initialement
for i in range(101):
    lien.append(i**2)   # ajout du carré en fin de liste

Ce script convient mais le temps d'exécution est "assez long" puisque la liste lien est modifiée 101 fois.
Pour être plus rapide, une amie vous annonce qu'il est possible de créer la même liste en une seule fois en utilisant la structure suivante, pour réaliser une création en compréhension :

lien = [i**2 for i in range(101)]       # liste directement créer en suivant une formule

Il est possible de créer une liste en compréhension avec une structure de la forme : [formule for variable in ensemble (éventuellement avec une condition supplémentaire)]

Voici différents script où une liste est créé compréhension.
À chaque script, deviner la liste obtenue puis le vérifier en exécutant le script proposé dans un IDE.

  1. liste1=[2*x for x in range(10)]
  2. liste2=[x**2 for x in range(10)]
    import math
    liste3=[math.sqrt(x) for x in liste2]
  3. liste=[3,-8,"mot",True,4.5,6]
    liste4 = [x**2 for x in liste if type(x)==int]

Code de déblocage de la correction :

Dans le dernier cas de l'exercice précédent, remarquer que la condition portant sur la variable est saisie grâce à un if et ce après le in ensemble.

Dans cet exercice, vous devez écrire deux scripts Python qui créent la liste des entiers de 0 à 10000 de deux méthodes différentes :

  1. en extension.

  2. en compréhension.

Code de déblocage de la correction :

Dans cet exercice, vous pouvez vous servir ou pas du fait que a%2 renvoie le reste de la division euclidienne de a par 2.

  1. Créer en extension une liste qui contienne les nombres pairs inférieurs à 10000.

  2. Créer en compréhension une liste qui contienne les nombres pairs inférieurs à 10000.

  3. Créer en compréhension une liste qui contienne les nombres impairs inférieurs à 10000.

Code de déblocage de la correction :

Tableaux et fonctions

Voici une fonction dont l'en-tête est incomplète ; il manque le type de retour

def test(a :list)->...:
	return [x**2 for x in a if x>0],[x for x in a if x>10]
a=[-4,-3,-2,0,1,5,9,11]
		
  1. Décrire le type du retour de la fonction et le rajouter à l'en-tête.

  2. Expliquer ce que fait cette fonction et le rajouter comme documentation à cette fonction.

Code de déblocage de la correction :

Le personnage d'un jeu vidéo possède un certain nombre d'objets dont l'ensemble est modélisé par la liste besace.
Supposons que ce personnage possède les objets de la liste suivante : besace = ["armure", "canne", "heaume", "cuir", "sérum", "chapeau", "pain"].

Proposer un script qui permet de créer, si possible par compréhension, la liste besace_C des objets dont le nom commence par la lettre "C".

Code de déblocage de la correction :

Résumé des opérations et des méthodes

On peut appliquer aux listes toutes les méthodes, fonctions et opérations des tuples.
En tant qu'objet mutable, les listes possèdent en plus des fonctions et des méthodes propres.
Voici les méthodes, fonctions et opérations à connaître sur les listes :

Opérations/méthodes Description
Méthodes et opérations communes aux listes et tuples.
elt in lst Renvoie True si un élément lst est égale à elt, False sinon
elt not in lst Renvoie True si aucun un élément de lst n'est égale à elt, False sinon
len(lst) Renvoie le nombre d'éléments de lst
lst1 == lst2 Renvoie True si lst1 et lst2 sont de même type, ont la même longueur et ont des éléments égaux deux à deux.
lst[i] Renvoie l'élément d'indice i de lst. Le premier élément a pour indice 0.
lst[i:j] Renvoie une partie del liste lst, celle entre les indices i à j, j non inclus
lst.index(elt) Renvoie l'indice de la première apparition de elt dans lst
lst.count(elt) Renvoie le nombre d'apparitions de elt dans lst
lst1+lst2 Renvoie une nouvelle liste, liste résultant de la concaténation de lst1 et de lst2.
lst*n Renvoie une nouvelle liste résultant de la concaténation de lst avec lui-même n fois.
Méthodes et opérations applicables aux listes (mais pas aux tuples).
lst.append(elt) Ajoute l'élément elt à la fin de la liste lst.
lst[i] = elt Modifie la liste lst en affectant la valeur elt à la case d'indice i.
Attention, cette case doit exister.
lst.insert(i,val) Insère l'élément val dans la liste lst à l'indice i.
Cette méthode décale les indices suivants.
lst.remove(elt) Supprime de la liste lst le premier élément dont la valeur est égale à elt
lst.pop(i) Enlève de la liste l'élément à la position i et renvoie sa valeur.
En l'absence d'élément en position i, c'est le dernier élément qui est supprimé et renvoyé
lst.sort() Modifie la liste lst en la triant
lst.reverse() Modifie la liste lst en inversant l'ordre de ses éléments

Voici un programme en python :

# -*- coding: utf-8 -*-
import random 

liste=[random.randint(1,6) for i in range(1000)] 
  1. Que contient la liste liste ?

  2. Combien d'éléments contient cette liste ?

  3. Écrire un script Python qui renvoie une liste contenant le nombre de 1,2,3,4,5 et 6. (vous utilisererez ici la méthode count).

Code de déblocage de la correction :

Écrire une fonction "count" sans "count"

  1. Écrire une fonction compter(element,liste) qui a pour arguments un entier (element) et une liste d'entiers (liste) qui renvoie le nombre d'occurrence de élément dans liste.

  2. Utiliser la fonction compter pour refaire l'exercice précédent.

  3. Prolongement possible : remplacer element par une liste d'éléments dans les arguments de la fonction compter.

Code de déblocage de la correction :

Les tableaux de tableaux

Les éléments d'un tableau peuvent être également un tableau. Ce type d'objet rappelle un objet mathématiques que vous verrez plus tard qui s'appelle une matrice. Cet objet est utilisé dans de nombreux domaines, notamment dans le traitement des images. Une image est une matrice de pixels.

Matrices

On appelle matrice un tableau de tableaux dont chaque tableau à la même longueur.

Chaque élément d'une matrice A est noté $a_{i,j}$ où $i$ est le numéro de ligne et $j$ le numéro de colonne.

On représente une matrice de taille $n$,$m$ en mathématiques ainsi :

$A = \begin{pmatrix} a_{1,1} & a_{1,2} & \cdots & a_{1,m} \\ a_{2,1} & a_{2,2} & \cdots & a_{2,m} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n,1} & a_{n,2} & \cdots & a_{n,m} \end{pmatrix}$

En Python, une matrice est une liste de listes de même longueur.

Pour accéder à un élément organisé en liste de listes, on utilise une notation avec un double crochets. Le premier indice pointe la ligne et le deuxième indice pointe la colonne.

Si notre matrice contient $n$ listes de $m$ éléments on peut la voir ainsi :

$L= \begin{pmatrix} L[0][0] & L[0][1] & \cdots & L[0][m-1] \\ L[1][0] & L[1][1] & \cdots & L[1][m-1] \\ \vdots & \vdots & \ddots & \vdots \\ L[n-1][0] & L[n-1][1] & \cdots & L[n-1][m-1] \end{pmatrix}$

Pour accéder à l'élément j de la ième liste de L on écrira :

L[i][j]

L=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]

Ici , L[1][2]=7

L=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]

Le premier élément de la liste L est la liste [1,2,3,4] ; pour l'afficher on écrit : L[0].

Le troisième élément de cette liste [1,2,3,4], notée L[0], est 3 ; pour y accéder nous utiliserons L[0][2]

  1. Afficher le quatrième élément du deuxième élément de la liste.

  2. Afficher le deuxième élément du troisième élément de la liste.

  3. Afficher l'élément indexé 0 du deuxième élément de la liste.

  4. Afficher L[2][3].

  5. Ajouter la valeur 26 à la deuxième liste. L est-elle encore une matrice ?

Code de déblocage de la correction :

Créer une fonction mat_nulle qui prend en paramètre deux nombres entiers n et m et qui renvoie une matrice de n lignes et m colonnes formée uniquement de 0.

Code de déblocage de la correction :

exercice de renforcement

On peut se servir de données structurées en liste de listes sans que ce soit des matrices.

Écrire une fonction matriceAlea(n:int,m:int)->list en langage Python qui renvoie une matrice à n lignes et m colonnes d'entiers aléatoires entre 0 et 100.

Code de déblocage de la correction :

Proposer une fonction entiers_en_matrice qui prend en paramètres deux nombres entiers n et m et qui renvoie la matrice formée par tous les nombres entiers compris entre 0 et $m\times n-1$ de telle sorte que ces nombres entiers soient rangés par ordre croissant lors du parcours de la matrice suivant chaque ligne de "haut en bas".
Par exemple, entiers_en_matrice(3,5) renvoie [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]] et entiers_en_matrice(4,1) renvoie [[0], [1], [2], [3]]

Code de déblocage de la correction :

Une image en noir et blanc peut être codée pixel par pixel informatiquement par un tableau en deux dimensions formés de 0 et de 1, où le 1 code noir et 0 blanc.
Voici une telle image :

  1. Proposer un tableau 2D en langage Python représentant le codge en noir et blanc de l'image ci-dessus.

  2. Le négatif d'une image en noir et blanc est une image de même taille où dans la représentation informatique les 1 ont été changé en 0 et où les 0 ont été changé en 1.
    Proposer une fonction creer_negatif qui prend en paramètre un tableau 2d sous forme de liste de listes et qui renvoie le tableau 2D où tous les 1 et les 0 ont été changés en leur complémentaire.

  3. Tester la fonction sur le tableau 2D représenetant l'image ci-dessus.

Code de déblocage de la correction :

Exercices

Le but de cet exercice est de représenter un jeu de 32 cartes.

Un jeu de 32 cartes est composé de :

  1. Modélisation du problème.

    1. Comment modéliser une carte en Python ?

    2. Comment modéliser un jeu de cartes ?

    Code de déblocage de la correction :

  2. Implémentation en Python.

    Le but est d'implémenter un jeu de 32 cartes et se doter de fonctions qui permettent interagir avec ce jeu.

      Lorsque vous écrivez des fonctions :
    • Il faut typer vos fonctions. Exemple : creation_jeu32(couleur:tuple, valeur32:tuple)->list

    • Il faut écrire une aide explicative docstring, entre " ", ou entre """ """" (si l'aide fait plusieurs lignes).

    1. Créer une fonction creation_jeu32(couleur:tuple, valeur32:tuple)->list qui retourne une liste de 32 cartes.

    2. Vérifier que le jeu possède 32 cartes.

    3. On veut pouvoir mélanger le jeu de 32 cartes. Il existe une fonction "shuffle(liste)" qui mélange les éléments d'une liste. Écrire une fonction melange(jeu:list)->list qui renvoie le jeu de cartes mélangé.

    4. On veut pouvoir tirer une carte au hasard du jeu. Si le jeu est mélangé, cela peut être la première carte. Il faut penser à retirer la carte du jeu. carte_hasard(jeu:list)->tuple

    5. On veut pouvoir créer une "main" de 5 cartes. Une main signifie un ensemble de cartes. Écrire une fonction main(nombre_cartes: int,jeu:list)->list: qui renvoie une main formée du nombre de cartes. Il faut penser à retirer la main créée du jeu de 32 cartes.

  3. Code de déblocage de la correction :

  4. Vers une autre structure de données construites.

    On veut pouvoir comparer des cartes pour réaliser par exemple des jeux.

    1. Modélisation

      1. Comment modéliser la "force" d'une carte ?

      2. Comment modéliser le jeu de cartes avec la force de chaque carte ?

    2. Implémentation en Python

      1. Écrire une fonction force(carte:tuple)->int: qui renvoie la "force" de la carte.

      2. Écrire une fonction jeu_force(jeu) qui renvoie le jeu des cartes associées à leur force .

      3. On veut comparer deux cartes. Écrire une fonction en Python compare(carte1:tuple,carte2:tuple,jeu_force:dict)->tuple qui renvoie la carte avec la force la plus élevée.

      4. Inventer une notion de distance entre deux cartes. Écrire une fonction distance(carte1:tuple,carte2:tuple)->int qui renvoie la "distance" entre deux cartes.

Code de déblocage de la correction :

Le prolongement de cette activité est la création d'un jeu (bataille, rami, blackjack, poker, pyramide, etc.). La création d'un jeu pourra être développée dans le cadre de votre projet.

Faire une recherche sur le web sur la notion de carré magique. Un carré magique d'ordre 3 est une matrice de 3 lignes et trois colonnes dont la somme des lignes, des colonnes et des diagonales fait le même nombre.

L=[	[2,7,6],
	[9,5,1],
	[4,3,8]]
	

Écrire un script Python qui vérifie que ce carré est magique. Le prolongement de cet exercice est la recherche de carrés magiques à partir de carrés à compléter.

Code de déblocage de la correction :

Python considère une phrase comme une séquence. Vous pouvez réaliser des essais avec cette citation célèbre du philosophe Confusius : "Je ne cherche pas à connaître les réponses, je cherche à comprendre les questions." De quelle type de séquence se rapproche-t-on? De la liste et/ou du tuple ? Faire des tests à partir de vos connaissances en python.

# -*- coding: utf-8 -*-
citation="Je ne cherche pas à connaître les réponses, je cherche à comprendre les questions."

# Quelques tests à faire :

citation[3]
citation[4]='z'
citation.append('!')

# En chercher d'autres 


En utilisant la méthode count(elt), compter le nombre de 'a' dans la citation, le nombre de 'e', le nombre de voyelles, etc.

Code de déblocage de la correction :

Il existe pour les listes des méthodes très intéressantes dans le traitement des chaînes de caractères. Ce sont les méthodes split() et join(). Observer le code proposé et réaliser les affichages des listes créées. Penser à également utiliser la commande type(variables) afin de vérifier le type des variables créées.

En utilisant ces principes, comment faire pour créer une liste de mots à partir de la chaine de caractères suivante : chaine="un,deux,trois,quatre,cinq" ?

Code de déblocage de la correction :

Extraire des groupes aléatoires.

L'objectif est de créer une fonction groupe(taille,nom_csv) qui prend pour argument un entier : taille correspondant à la taille des groupes voulus et une chaine de caractère nom_csv correspondant au nom du fichier csv qui renvoie la répartition des groupes à la bonne taille de manière aléatoire.

Le matériel nécessaire se compose d'un fichier csv téléchargeable ici

Chaque individu possède trois attribut Prénom, Nom, Race

Les individus sont des "peaux vertes" constitués d'orques et de gobelins.

Quelques aides à la réalisation de ce travail :

Code de déblocage de la correction :

Prolongement possible :

  1. Réécrire la fonction précédente qui ajoute un numero de groupe à chaque groupe.

  2. Code de déblocage de la correction :

  3. Faire en sorte de réécrire un csv avec la listes des élèves avec leur numéro de groupe.

Code de déblocage de la correction :

Exercices de renforcement

Tuple

Dans la gestion d'un jeu vidéo, vous avez stocké l'ensemble des châteaux visités par deux joueurs dans deux tuples différents :

joueur_1=("chateau_ride","chateau_tot","chateau_mat","chateau_no","chateau_que_sain","chateau_plat")
joueur_2=("chateau_mat","chateau_car","chateau_lier","chateau_ride","chateau_no","chateau_paz")

Utiliser les méthodes et les opérations du tableau pour tester les différentes questions :

  1. Tester si le joueur 1 a visité ou non le château "chateau_paz".

  2. Quel est le premier château visité par le joueur 1 ?

  3. Combien de château a visité le joueur 1 ?

  4. Quel est le dernier château voisité par le joueur 1 ?

  5. Tester si les deux joueurs ont visités les mêmes châteaux.

  6. Donner l'ensemble des noms des châteaux visités par le joueur 2 entre le deuxième château visité et le cinquième.

  7. renvoyer l'indice de "chateau_ride" dans le tuple joueur_2.

  8. Renvoyer le nombre de "chateau_mat" dans joueur_1 pusi dans joueur_2.

  9. Créer un tuple ensemble par concaténation de joueur_1 et de joueur_2.
    Ce tuple possède-t-il des doublons ?

Cliquer pour afficher la solution
  1. "chateau_paz" in joueur_1 renvoie False : le joueur 1 n'a pas visité ce château.

  2. joueur_1[0] renvoie "chateau_ride" : c'est le premier château visité par le joueur 1.

  3. len(joueur_1) renvoie 6 : le joueur 1 a visité 6 châteaux.

  4. joueur_1[-1] tout comme joueur_1[len(joueur_1)] renvoie "chateau_plat" : c'est le dernier château visité par le joueur 1.

  5. joueur_1 == joueur_2 renvoie False : les deux joueurs n'ont pas visité les mêmes châteaux.

  6. joueur_2[1:5] renvoie "chateau_car","chateau_lier","chateau_ride","chateau_no" : ce sont le nom des châteaux visités par le joueur 2 entre le deuxième et le cinquième.

  7. joueur_2.index("chateau_ride") renvoie 3 : "château_ride" est le quatrième château visité par le joueur 2.

  8. joueur_1.count("chateau_mat") renvoie 0 et joueur_2.count("chateau_mat") renvoie 1 : "chateau_mat" a été visité par le joueur 2 mais pas par le joueur 1.

  9. ensemble = joueur_1+joueur_2 réuni comme tuple l'ensemble des châteaux visités.
    Les châteaux visités par les deux joueurs apparaissent deux fois :
    Voici le contenu du tuple ensemble : ('chateau_ride', 'chateau_tot', 'chateau_mat', 'chateau_no', 'chateau_que_sain', 'chateau_plat', 'chateau_mat', 'chateau_car', 'chateau_lier', 'chateau_ride', 'chateau_no', 'chateau_paz')

Vous avez passé un concours d'informatique. L'ensemble des noms des personnes reçues au concours est implémenté comme un tuple de chaînes de caractères.
Par exemple, si "Nguyen", "Traoré" et "Dupont" sont les noms des trois personnes reçues au concours, l'ensemble des personnes reçues est ("Nguyen","Traoré","Dupont").

Afin de savoir facilement si vous êtes reçu.e ou non, vous décidez de créer une fonction est_recu_e.

Écrire une fonction est_recu_e qui :

Tester ensuite la fonction créée.

Cliquer pour afficher la solution
def est_recu_e(tup_admis:tuple,nom:str)->bool:
    """
    tup_admis est le tuple de chaînes de caractères stockant l'ensemble des noms des personnes admises au concours.
    nom est la chaîne de caractères de la personne.
    Fonction qui renvoie un booléen en fonction que la personne ayant pour nom de famille nom est reçue ou non.
    """
    admis = False 
    for elt in tup_admis:
        if elt == nom:
            admis = True 
    return admis
            

On peut vérifier que :

Liste

Vous gérez la mini station météo de votre lycée. Cette station mesure entre autre la température extérieure à différents moments de la journée. L'ensemble des températures mesurées est stocké dans une liste.
Par exemple, si la station a mesuré successivement les températures 12, 13.1, 13.7, 14 et 13.1, l'ensemble des températures est [12,13.1,13.7,14,13.1].

Vous vous rendez compte que la sonde mesurant ces températures est déréglée si bien que toutes les températures mesurées sont supérieures de 2 degrés à la température réelle.

Afin de corriger l'ensemble des mesures obtenues, vous décidez de créer une fonction baisser2.

Écrire une fonction baisser2 qui :

Tester ensuite la fonction créée.

Cliquer pour afficher la solution
def baisser2(temperatures:list)->list:
    """
    temperature est une liste de nombres supposée contenir les températures mesurées.
    Fonction qui la liste où toutes les valeurs ont été diminuées de 2.
    """
    # balayage de toute la liste à partir des index
    for i in len(temperatures):
        temperature[i] = temperature[i]-2   # diminution de la valeur de 2 et remplacement dans la liste
    return temperature
            

On peut vérifier que baisser2([12,13.1,13.7,14,13.1]) renvoie bien [10,11.1,11.7,12,11.1].

Écrire une fonction trouver qui prend en paramètre une liste de nombres lst et une valeurs val et qui renvoie la liste des indices des éléments de lst égaux à val.
Par exemple, trouver([12,15,12,12,16,48,12,16],12) renvoie la liste [0,2,3,6] tandis que trouver([12,15,12,12,16,48,12,16],17) renvoie la liste [].

Cliquer pour afficher la solution
def trouver(lst:list,val:float)->list:
    """lst est une liste de nombres et val un nombre.
    Cette fonction renvoie la liste des indices des éléments de lst égaux à val."""
    # création d'une liste vide
    liste_indices = []
    # balayage de toute la liste des valeurs
    for i in range(len(lst)):
        if lst[i] == val : # cas d'un élément égal à la valeur cherchée
            liste_indices.append(i)
    return liste_indices
            

On peut vérifier que trouver([12,15,12,12,16,48,12,16],12) renvoie bien [0,2,3,6] et que trouver([12,15,12,12,16,48,12,16],17) renvoie bien [].

  1. Écrire une fonction epaissir qui prend en paramètre une liste de nombres lst et un nombre entier non nul n et qui renvoie le tableau 2D (ou matrice) formées de n lignes, toutes identiques à la liste lst.
    Par exemple, epaissir([0,1,1,0,1,1,1,0,0,1],4) renvoie la liste

    [[0, 1, 1, 0, 1, 1, 1, 0, 0, 1],
     [0, 1, 1, 0, 1, 1, 1, 0, 0, 1],
     [0, 1, 1, 0, 1, 1, 1, 0, 0, 1],
     [0, 1, 1, 0, 1, 1, 1, 0, 0, 1]]
  2. Rajouter les préconditions permettant d'assurer le fait que les arguments saisis sont corrects.

Cliquer pour afficher la solution

1.

# En utilisant la compréhension de liste
def epaissir(lst:list,n:int)->list:
    """lst est une liste et n est un entier naturel non nul.
    Fonction qui renvoie une liste de n listes, toutes identiques à lst"""
    return [lst for i in range(n)]

# En utilisant l'extension de liste
def epaissir(lst:list,n:int)->list:
    """lst est une liste et n est un entier naturel non nul.
    Fonction qui renvoie une liste de n listes, toutes identiques à lst"""
    mat = []
    for i in range(n):
        mat.append(lst)
    return mat

2. Rajout de la précondition :

# Préconditions à rajouter après la documentation
    assert type(lst) is list, "le premier argument doit être une liste"
    assert type(n) is int, "le second argument doit être un entier"
    assert n>0, "le second argument doit être strcitement positif"

Licence Creative Commons
Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International