Chapitre 5 Types constuits

5.1 Activité 1: Tuples

Un tuple est une collection ordonnée d’éléments qui ne peuvent pas être modifiés. On dit qu’un tuple n’est pas mutable. On reconnaît un tuple par sa syntaxe avec des parenthèses.

Le programme suivant utilise un tuple pour coder une date. Explique en détail son déroulement.

date = (14, 'juillet', 1789)
jour = date[0]
mois = date[1]
annee = date[2]
print(f"La révolution française a eu lieu le {jour} {mois} de l'année {annee}")

Une fraction peut être considéré comme un comme de deux entiers (n , d). n est le numérateur et d le dénominateur. La fraction ainsi codée est \(\frac{n}{d}\). On veut écrire une fonction mul_frac capable de multiplier deux fractions. Cette fonction reçoit 2 tuples représentant les deux fractions à multiplier. Après calcul, la fonction renvoie sous la forme d’un tuple la fraction calculée. Complète et teste la fonction suivante:

def mul_frac(n1,d1,n2,d2):
  """
  In: n1,d1 première fraction et n2,d2 deuxième fraction
  Out: Tuple correspond à la fraction produit
  """
  n = ... * n2
  d = ....
  return n,...

print(mul_frac(1, 3, 2, 3))

Prédire et expliquer en détail le déroulement du programme suivant. Identifier la propriété des tuples qui est mise en évidence.

a = 4
b = 2
t = (a, b)
print(t)
a = 10
print(t)

Ecrire une fonction distance qui reçoit 2 points et renvoie la distance entre ces deux points. Chaque point est codée à l’aide d’un tuple dont les éléments sont les coordoonées x,y du point. Par exemple, un point A de coordonnées (5,4) sera codée avec le tuple (5,4).

# Fonction norme
...
A = (5, 4)
B = (2, 0)
print(distance(A, B)) #doit afficher 5.0

Vérifier avec un test unitaire que la fonction distance a le fonctionnement attendu.

5.2 Activité 2: Liste

Dérouler à la main le programme suivant:

pairs = [2, 4, 6, 7, 10]
print(pairs[1])
print(pairs[0])
print(pairs[-1])
pairs[3] = 8
taille = len(pairs)
for i in range(taille):
  print(f"L'élément d'indice {i} de la liste a pour valeur {pairs[i]}")
for n in pairs:
  print(f" ... {n}", end ="")

Il existe de manière de parcourir les éléments d’une liste (et aussi d’un tuple). Le programme ci-dessous utilisent le parcours en indice et le parcours par élément. Chaque boucle doit afficher successivement tous les éléments contenus dans liste. Complète le programme suivant:

liste = [ True, 42, "Dr.Dre", 3.14]
taille = len(liste)
# Parcours en indice
for indice in ... :
  print(...)
# Parcours par élément
for ... in ... :
  print(e)

Générer une liste par compréhension. Ecrire une déclaration de liste en compréhension afin que les tests unitaires passent avec succès.

l_1 = [0, 2, 4, 6, 8, 10]
l_2 = [ 2*n for n in range(6)]
assert l_1 == l_2
l_3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
l_4 = [...]
assert l_3 == l_4
l_5 = [1, 3, 5, 7, 9, 11]
l_6 = [...]
assert l_5 == l_6
# liste des entiers privée des multiples de 4
l_7 = [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18, 19]
l_8 = [ n for n in range(21) if ... ]
assert l_7 == l_8

Ecrire une fonction maxi qui reçoit comme argument une liste contenant des nombres et qui renvoie l’élément maximal. maxi([2, 1, 4.2, 13, -20]) retourne la valeur 13 qui porte bonheur !
Ecrire un programme qui demande à l’utilisateur combien de notes il a obtenu dans le semestre. Ensuite le programme demande chacune des notes obtenues et le coefficient correspondant. Exemple de sortie:

Entrer le nombre de notes: 2
Entrer la note numero 0: 12
Entrer le coefficient de la note: 3
Entrer la note numero 1: 11
Entrer le coefficient de la note: 1
note numero 0: 12.0 coefficients 3.0
note numero 1: 11.0 coefficients 1.0
La moyenne coefficientée vaut: 11.75

def recap(notes, coeffs):
  # Affiche le numero des notes, la valeur et le coeff
  ...
def moyenne_coefficientee(notes, coeffs):
  # A partir de la liste des notes et des coeffs calcul la moyenne coefficientée
  ...
  return ...
# Saisie des notes
nb_notes = int(input('Entrer le nombre de notes: '))
for i in range(nb_notes):
  n = float(input(f"Entrer la note numero {i}: "))
  notes.append(n)
  c = float(input('Entrer le coefficient de la note: '))
  coeffs.append(c)
# Affiche la récap des notes et coeff en appelant la fonction recap
recap(notes, coeffs)
# Calcul la moyenne en appelant la fonction moyenne_coefficientee
moyenne = moyenne_coefficientee(notes,coeffs)
print(f"La moyenne coefficientée vaut: {moyenne :<5.2f}")

5.3 Activité 3: Méthodes de liste et tableaux 2D

Le programme suivant illustrent les méthodes de listes les plus courantes. Etudier le programme suivant. Justifier ce que le programme va afficher. méthodes de listes

l = [3, 1, 4, 1, 5]
l.append(2)
print(l)
l.remove(1)
print(l)
del l[2]
print(l)
dernier = l.pop()
print(dernier)
print(l)
l.insert(1, 10)
print(l)

Le programme suivant crée une liste qui sauvegarde les valeurs obtenues par des jets de dés par l’utilisateur. Compléter le programme ci-dessous afin d’obtenir la sortie suivante:

Nombre de jets: 3
entrer la valeur: 5
entrer la valeur: 1
entrer la valeur: 3
Liste de vos jets de dés:
[5, 1, 3]

jets=[]
n = int(input('Nombre de jets: '))
for i in range(...):
    de = int(input('entrer la valeur: '))
    ...

print('Liste de vos jets de dés:')
print(...)

Ecrire une fonction insertion qui reçoit une liste l d’entiers triés par ordre croissant et une valeur v. La fonction va insérer au bon endroit dans l afin de maintenir la liste triée. La fonction retourne cette liste actualisée. Par exemple:

liste = [1, 3, 4, 9]
liste = insertion(liste, 5)
# liste contient alors [1, 3, 4, 5, 9]

Compléter le programme afin que tableau_2d contienne les éléments suivants:

[[0  , 0  , 'T'],
 ['X', 'X', 'T'],
 [0  , 0  , 'T']]

tableau_2d = [[0, 0, 0 ],
              [1, 0 ,0 ],
              [0, 0, 0 ]]
tableau_2d[1][0] = ...

for colonne in range(3):
    tableau_2d[...][...] = "X"

for ligne in range(3):
    tableau_2d[...][...] = "T"
    
print(tableau_2d)

Ecrire une fonction qui permet d’afficher la liste précédente sous la forme d’une grille comme l’exemple ci-dessous.

| 0 | 0 | T |
| X | X | T |
| 0 | 0 | T |

5.4 Activité 4: Pratique des listes

Exécute et analyse le programme suivant. Tu pourras t’aider de python tutor pour mieux visualiser l’exécution de ce code.

ma_liste = [1,2,3]
ma_liste_bis = l
ma_liste[0] = 0
print(ma_liste, ma_liste_bis)

Propose un moyen de réaliser une véritable copie d’une liste.
Illustre cette technique dans un petit programme

La fonction inverse_liste reçoit comme argument une liste et retourne un tableau obtenue en inversant les éléments de la liste passée.
Ecrire une fonction appartient qui reçoit une valeur v et une liste l. Cette fonction renvoie la valeur de l’indice correspondant à la première occurence de v dans l. Sinon la fonction retourne -1 si v n’appartient à l.
Ecrire une fonction genere qui reçoit comme argument un entier n et retourne une liste de n valeurs aléatoire comprise entre 1 et 6. La liste obtenue est un simulation de n jets de dé. Dans la suite on appelle jet cette liste.
A partir de la liste jet précédente, écrire une fonction occurence qui compte l’occurence de chacun des résultats. La fonction occurence.
A partir des deux fonctions précédentes, écrire un programme qui vérifie pour un grand nombre de tirage que la probabilité de 1, 2, 3, 4, 5 ou 6 vaut environ: 0,167. Afficher les probabilités calculées par le programme pour un tirage de 1000 dés. Exemple de résultats:

La probabilté de faire 1 est de 0.161
La probabilté de faire 2 est de 0.164
La probabilté de faire 3 est de 0.158
La probabilté de faire 4 est de 0.167
La probabilté de faire 5 est de 0.177
La probabilté de faire 6 est de 0.173

Aide: Pour calculer la probabilité de faire 3, on divise le nombre de fois qu’un 3 est sorti lors du tirage des 1000 dés. Puis on divise par mille qui est le nombre total de dés tirés. Ici le 3 est sorti 158 fois lors des mille tirages sa probabilité est donc 158/1000=0,158.

5.5 Activité 5: Dictionnaires

Commente ligne à ligne le programme suivant en nommant chacune des manipulations effectuées sur le dictionnaire capitales.

capitales = {"France": "Lutèce" , "Italie" : "Rome", "Suisse" : "Berne"}
print(capitales["France"])
print(capitales.get("France"))
capitales["France"] = "Paris"
capitales["Norvège"] = "Oslo"
liste_des_cles = capitales.keys()
print(liste_des_cles)
liste_des_valeurs = capitales.values()
print(liste_des_valeurs)
for valeur in capitales.values():
    print("Capitale : ", valeur)
for cle in capitales.keys():
    print("Pays : ", cle)
 for cle, valeur in capitales.items():
    print(f"Pays: {cle} - Capitale: {valeur}")

Le programme suivant permet d’enregistrer des contacts (nom et numero de tel) dans un répertoire. Chaque fiche contact est un dictionnaire à deux clés: name et phone. Le répertoire est une liste contenant toutes les fiches contacts. Techniquement le répertoire est une liste dont chaque élément est un dictionnaire.

Compléter le programme suivant afin de créer un répertoire. Exemple de sortie:

Entrer le nombre de contacts à enregistrer: 3
nom du contact Cook
numero de tel du contact 123456
nom du contact Gates
numero de tel du contact 15991123
nom du contact Bezos
numero de tel du contact 911
[{'name': 'Cook', 'phone': '123456'}, {'name': 'Gates', 'phone': '15991123'}, {'name': 'Bezos', 'phone': '911'}]

Programme à compléter:

repertoire = []
def ajouter_contact():
    contact = {}
    nom = input('nom du contact ')
    tel = input('numero de tel du contact ')
    contact['name'] = ...
    contact['...'] = tel
    return contact
# Construction du carnet d'adresse
nombre_contacts = int(input('Entrer le nombre de contacts à enregistrer: '))
for _ in range(...):
    repertoire.append(...)
# Affichage des enregistrements
print(repertoire)

Cette question utilise et prolonge la question précédente. Créer une fonction recherche_nom qui reçoit un nom et qui affiche le numero de téléphone du nom correspondant si celui-ci figure bien dans le repertoire.

Exemple de sortie:

Entrer un nom à rechercher Cook
Cook a pour telephone 123456

Expliquer le fonctionnement du programme suivant. On expliquera en détail la syntaxe: liste[0][0] et liste[0][1]

reponse_1 = { "blanc": True , "jaune" : False , "vert" : False , "D la réponse D" : False}
question_1 = "Quelle est la couleur du cheval d'Henri IV ?"
liste = [(question_1, reponse_1)]
#Affiche la premiere question
print(liste[0][0])
#Affiche les propositions
for cle in liste[0][1]:
    print(cle)
    
response_utilisateur = input('Entre votre réponse: ')
# Analyse de la réponse
if liste[0][1][response_utilisateur] == True:
    print('Bonne réponse')
else :
    print('FAUX')

Modifier le programme précédent afin de signaler lorsque l’utilisateur commet une faute de frappe en entrant au clavier autre chose qu’une des propositions.
Améliorer le programme afin qu’il comporte au moins 3 questions. Les questions sont posées dans un ordre aléatoire. Lorsque toutes les questions ont été posées le nombre de bonnes réponses est affichées.

5.6 Corrections des activités

5.6.1 Activité 1

from math import *
def distance(v1, v2):
  return sqrt((v1[0] - v2[0]) **2 + (v1[1] - v2[1]) **2)

A = (5, 4)
B = (2, 0)
print(distance(A, B))

## 5.0

5.6.2 Activité 2

Sortie

5.0
4
2
10
 ... 2 ... 4 ... 6 ... 8 ... 10L'élément d'indice 0 de la liste a pour valeur 2
L'élément d'indice 1 de la liste a pour valeur 4
L'élément d'indice 2 de la liste a pour valeur 6
L'élément d'indice 3 de la liste a pour valeur 8
L'élément d'indice 4 de la liste a pour valeur 10

def recap(notes, coeffs):
  for i in range(len(notes)):
    print(f"note numero {i}: {notes[i]} coefficients {coeffs[i]}")
def moyenne_coefficientee(notes, coeffs):
  somme_des_points = 0
  somme_des_coeffs = 0
  for i in range(len(notes)):
    somme_des_points += notes[i] * coeffs[i]
    somme_des_coeffs += coeffs[i]
  return somme_des_points / somme_des_coeffs
nb_notes = int(input('Entrer le nombre de notes: '))
for i in range(nb_notes):
  n = float(input(f"Entrer la note numero {i}: "))
  notes.append(n)
  c = float(input('Entrer le coefficient de la note: '))
  coeffs.append(c)

recap(notes, coeffs)
moyenne = moyenne_coefficientee(notes,coeffs)
print(f"La moyenne coefficientée vaut: {moyenne :<5.2f}")

5.6.3 Activité 3:

tableau_2d = [[0, 0, 0 ],
              [1, 0 ,0 ],
              [0, 0, 0 ]]
tableau_2d[1][0] = 0
for colonne in range(3):
    tableau_2d[1][colonne] = "X"
for ligne in range(3):
    tableau_2d[ligne][2] = "T"
    
print(tableau_2d)

## [[0, 0, 'T'], ['X', 'X', 'T'], [0, 0, 'T']]

for ligne in range(3):
    for colonne in range(3):
        print(f"|{tableau_2d[ligne][colonne] : ^3}", end = "")
    print("|")

## | 0 | 0 | T |
## | X | X | T |
## | 0 | 0 | T |

5.6.4 Activité 4:

from random import randint

def jet(n):
    l = []
    for i in range(n):
        l.append(randint(1,6))
    return l

def occurrence(liste, valeur):
    compteur = 0
    for e in liste:
        if e == valeur:
            compteur += 1
    return compteur

print('Tirage ')

## Tirage

resultat = jet(1000)
print(resultat)

## [1, 4, 5, 6, 1, 6, 1, 4, 6, 4, 1, 4, 1, 3, 5, 4, 3, 6, 1, 3, 4, 6, 5, 6, 4, 1, 2, 5, 3, 2, 6, 2, 5, 2, 1, 2, 6, 3, 5, 4, 6, 6, 4, 1, 5, 6, 3, 6, 1, 4, 6, 1, 5, 6, 2, 3, 3, 1, 3, 6, 6, 4, 1, 2, 1, 1, 1, 2, 3, 2, 5, 1, 5, 2, 3, 6, 4, 1, 3, 1, 6, 2, 2, 4, 5, 1, 2, 1, 5, 5, 1, 1, 4, 4, 4, 4, 2, 6, 1, 2, 1, 2, 3, 3, 5, 3, 5, 5, 6, 2, 5, 4, 1, 2, 5, 1, 6, 4, 6, 6, 6, 4, 2, 4, 1, 1, 2, 6, 6, 6, 3, 4, 2, 6, 2, 2, 6, 5, 2, 4, 3, 2, 2, 4, 6, 4, 4, 5, 2, 5, 5, 1, 3, 1, 6, 2, 1, 6, 3, 2, 2, 3, 4, 4, 5, 3, 5, 1, 5, 4, 6, 6, 3, 5, 6, 4, 5, 1, 5, 6, 5, 1, 4, 4, 6, 5, 4, 1, 3, 2, 2, 2, 5, 6, 6, 4, 6, 3, 3, 2, 2, 3, 3, 4, 6, 4, 3, 1, 3, 5, 2, 6, 2, 1, 1, 6, 4, 6, 3, 4, 1, 1, 4, 4, 6, 1, 2, 1, 6, 2, 6, 4, 1, 4, 3, 3, 6, 1, 2, 5, 6, 4, 6, 5, 5, 3, 2, 3, 5, 4, 2, 1, 2, 4, 3, 4, 2, 2, 3, 6, 5, 2, 5, 5, 2, 6, 2, 2, 2, 5, 1, 4, 6, 1, 4, 1, 5, 4, 2, 3, 3, 5, 6, 5, 6, 1, 5, 6, 2, 5, 5, 1, 4, 1, 2, 2, 1, 4, 2, 3, 6, 6, 1, 4, 2, 5, 5, 6, 2, 1, 5, 5, 2, 3, 1, 5, 2, 5, 5, 5, 4, 2, 2, 4, 3, 3, 3, 4, 5, 5, 3, 1, 6, 6, 4, 3, 5, 5, 2, 1, 1, 1, 4, 2, 5, 3, 5, 1, 1, 2, 1, 3, 3, 2, 5, 6, 3, 5, 2, 1, 5, 4, 3, 1, 4, 2, 2, 6, 2, 5, 3, 3, 1, 1, 2, 5, 3, 3, 2, 2, 4, 4, 3, 5, 3, 6, 6, 2, 1, 4, 3, 2, 2, 2, 5, 3, 2, 1, 6, 4, 1, 6, 3, 4, 2, 3, 3, 5, 3, 4, 1, 2, 4, 3, 3, 2, 2, 5, 6, 4, 2, 6, 6, 4, 4, 4, 2, 6, 3, 3, 1, 4, 4, 1, 4, 6, 4, 4, 1, 4, 1, 5, 2, 6, 6, 1, 3, 6, 4, 4, 4, 5, 5, 3, 4, 3, 5, 1, 5, 1, 5, 4, 5, 5, 4, 2, 5, 1, 6, 6, 4, 5, 4, 1, 5, 2, 5, 4, 3, 4, 3, 4, 5, 6, 5, 6, 1, 5, 4, 6, 1, 2, 6, 2, 5, 1, 6, 2, 1, 4, 5, 5, 1, 3, 2, 6, 5, 3, 2, 1, 3, 5, 5, 3, 1, 4, 5, 2, 2, 2, 2, 4, 4, 6, 1, 3, 2, 4, 3, 4, 4, 2, 5, 4, 1, 2, 5, 3, 2, 6, 2, 2, 3, 2, 1, 2, 6, 3, 4, 5, 2, 1, 3, 1, 2, 5, 3, 2, 1, 1, 4, 3, 3, 3, 3, 6, 6, 5, 3, 2, 3, 2, 1, 4, 4, 3, 6, 2, 5, 6, 6, 4, 1, 2, 3, 6, 3, 5, 5, 3, 6, 4, 4, 3, 6, 4, 4, 5, 2, 3, 5, 4, 4, 2, 1, 4, 6, 6, 4, 4, 3, 6, 5, 5, 6, 2, 2, 2, 4, 4, 1, 5, 6, 5, 4, 3, 6, 3, 5, 1, 4, 2, 1, 4, 4, 2, 1, 6, 1, 1, 3, 2, 3, 6, 5, 2, 2, 1, 3, 1, 5, 4, 4, 1, 6, 6, 2, 6, 4, 3, 6, 3, 2, 1, 1, 4, 5, 2, 2, 4, 1, 3, 6, 6, 6, 3, 4, 1, 6, 2, 6, 5, 6, 6, 1, 4, 6, 6, 2, 3, 3, 4, 2, 5, 2, 3, 1, 5, 1, 3, 5, 6, 3, 3, 1, 5, 4, 4, 4, 1, 1, 4, 1, 5, 2, 4, 6, 1, 1, 4, 3, 6, 4, 1, 2, 3, 3, 3, 4, 3, 2, 3, 5, 2, 1, 6, 1, 5, 5, 5, 3, 6, 6, 4, 5, 4, 3, 5, 2, 6, 2, 1, 2, 4, 4, 2, 2, 6, 6, 6, 5, 6, 6, 4, 4, 2, 3, 5, 6, 5, 6, 4, 6, 4, 5, 1, 6, 4, 4, 6, 1, 1, 6, 4, 6, 4, 5, 6, 6, 1, 1, 5, 4, 5, 1, 4, 1, 1, 1, 1, 3, 6, 5, 5, 6, 4, 5, 1, 5, 1, 6, 6, 1, 6, 6, 3, 6, 5, 2, 1, 6, 6, 6, 4, 5, 5, 4, 5, 4, 6, 3, 4, 1, 2, 1, 3, 2, 2, 1, 4, 2, 4, 5, 4, 2, 1, 2, 3, 3, 6, 5, 5, 5, 3, 6, 5, 2, 2, 3, 3, 3, 3, 5, 2, 1, 4, 3, 2, 6, 3, 1, 3, 3, 4, 2, 1, 5, 5, 1, 1, 6, 6, 1, 5, 3, 2, 3, 3, 3, 6, 1, 4, 2, 2, 6, 5, 2, 2, 5, 5, 4, 4, 1, 6, 2, 3, 3, 6, 3, 4, 4, 4, 5, 1, 6, 1, 1, 4, 5, 3, 5, 1, 4, 6, 2, 4, 4, 3, 1, 2, 6, 1, 1, 4, 1, 2, 5, 1, 4, 6, 3, 5, 3, 6, 6, 2, 6, 1, 2, 5, 1, 2, 5, 2, 1, 6, 6, 6, 5, 1, 3, 2, 6, 2, 4, 6, 6, 4, 3, 5, 2, 1, 6, 6, 4, 6, 2, 4, 3, 6, 3, 5, 5, 2, 3, 1, 4, 2, 4, 2, 2, 4, 1, 5, 3, 5, 5, 1, 1, 6]

for v in range(1,7):
    print(f"La probabilté de faire {v} est de {occurrence(resultat, v)/1000}")

## La probabilté de faire 1 est de 0.167
## La probabilté de faire 2 est de 0.171
## La probabilté de faire 3 est de 0.151
## La probabilté de faire 4 est de 0.175
## La probabilté de faire 5 est de 0.162
## La probabilté de faire 6 est de 0.174

5.6.5 Activité 5:

capitales = {"France": "Lutèce" , "Italie" : "Rome", "Suisse" : "Berne"}
# Récupérer une valeur à partir de la clé
print(capitales["France"])

## Lutèce

print(capitales.get("France"))
# Changement de Valeur

## Lutèce

capitales["France"] = "Paris"
# Ajouter un élément dans le dictionnaire
capitales["Norvège"] = "Oslo"
# Récupérer la liste des clés
liste_des_cles = capitales.keys()
print(liste_des_cles)
# Récupérer la liste des valeurs

## dict_keys(['France', 'Italie', 'Suisse', 'Norvège'])

liste_des_valeurs = capitales.values()
print(liste_des_valeurs)
# Parcours des valeurs

## dict_values(['Paris', 'Rome', 'Berne', 'Oslo'])

for valeur in capitales.values():
    print("Capitale : ", valeur)
# Parcours des clés

## Capitale :  Paris
## Capitale :  Rome
## Capitale :  Berne
## Capitale :  Oslo

for cle in capitales.keys():
    print("Pays : ", cle)
# Parcours clé + valeur

## Pays :  France
## Pays :  Italie
## Pays :  Suisse
## Pays :  Norvège

for cle, valeur in capitales.items():
    print(f"Pays: {cle} - Capitale: {valeur}")

## Pays: France - Capitale: Paris
## Pays: Italie - Capitale: Rome
## Pays: Suisse - Capitale: Berne
## Pays: Norvège - Capitale: Oslo

reponse_1 = { "blanc": True , "jaune" : False , "vert" : False }
question_1 = "Quelle est la couleur du cheval d'Henri IV ?"
liste = [(question_1, reponse_1)]
#Affiche la premiere question
print(liste[0][0])
#Affiche les propositions
for cle in liste[0][1]:
    print(cle)
    
response_utilisateur = input('Entre votre réponse: ')
# Analyse de la réponse
if liste[0][1][response_utilisateur] == True:
    print('Bonne réponse')
else :
    print('FAUX')