N.S.I.
Projets année 2022-2023
Projet 1 : Notation PIX
Objectif : convertir en note sur 20 un score PIX
1) Premièrement, c'est l'utilisateur qui choisit la moyenne de la note. Ainsi, selon ce chiffre, le résultat du programme variera. Nous allons créer le programme en vérifiant chaque étape le code, pour ainsi être sûr du bon fonctionnement du programme final. Le premier code tapé est :
Moyenne_choisie = int(input("Veuillez choisir la moyenne :"))
print(Moyenne_choisie)
Voici ce que donne le programme :
2) Ensuite, nous allons voir comment établir une fonction donnant la moyenne :
Grâce à l'aide du site https://fr.acervolima.com/trouver-la-moyenne-dune-liste-en-python/
nous pouvons établir la fonction de la moyenne qui serait :
def Moyenne(score): #Definir une fonction appelée Moyenne ayant en paramètre score#
return sum(score) / len(score) #retourner à la somme de la liste divisé par le nombre d'éléments dans la liste#
score = [100,200,500] #Définir à la variable score les scores de chacun sous forme de liste#
moyenne = Moyenne(score) #Définir à la variable moyenne la fonction Moyenne ayant en paramètre score#
print("la moyenne est",round(moyenne,2)) #Afficher la moyenne arrondie à 2 chiffres après la virgule#
Voici ce que donne le programme :
3) Maintenant, nous allons déterminer le score minimum. Grâce a un des cours vu en classe, nous pouvons établir la fonction du score minimum :
score=[129,20,648] #Exemple de possibilité de la liste des scores des élèves#
def score_minimum(score): #Définir une fonction appelée score_minimum ayant en paramètre score#
min=score[0] #On définit à min le nombre minimum (0) par rapport à la liste#
for element in score : #Dans la boucle for, on dit pour un élément dans la liste...#
if element <= min : #boucle si, conditionnelle, l'élément est inférieur ou égale à min#
min = element #Si la boucle si est remplie alors min devient element#
return min #Retourner à min#
print("le score minimum est",score_minimum (score)) #Afficher le résultat du score minimum#
Voici ce que donne le programme :
3) Pour poursuivre, nous allons déterminer le score maximum. En nous aidant de ce que l'on a vu pour le score minimum, nous pouvons établir la fonction du score maximum :
score=[129,20,648] #Exemple de possibilité de la liste des scores des élèves#
def score_maximum(score): #Définir une fonction appelée score_maximum ayant en paramètre score#
max=score[0] #On définit à min le nombre maximum (0) par rapport à la liste#
for element in score : #Dans la boucle for, on dit pour un élément dans la liste...#
if element >= max : #boucle si, conditionnelle, l'élément est inférieur ou égale à max#
max = element #Si la boucle si est remplie alors max devient élément#
return max #Retourner à max#
print("le score maximum est",score_maximum (score)) #Afficher le résultat du score maximum#
Voici ce que donne le programme :
4) Après avoir vu tout ceci, nous pouvons voir comment afficher l'élément 0 de la liste score avec le même élément pour la liste prenom et ainsi de suite pour permettre d'avoir un bon affichage à la fin du programme :
score=[303,480,600,312,378,473,288,301,371,230,149,265,243,236]#liste des scores pix de chaque élèves#
prenom=["Maxence","Dina","Enzo","Fantine","Gabin","Léo","Lilian","Mathis","Melvyn","Salma","Lila","Joseph","Alexandre","Lilou"]#liste des prénoms de chaque élève#
note_20=[12,23,32,42,34,23,12,12,54,6,94,12,34,54]#liste inventé des notes de chaque élève( (modifié après le programme)#
for i in range(0,14,1): #boucle for pour la valeur i qui commencera de l'élément 0 à 13 ayant 1 de décalage# x=score[i] #La variable x est définit par l'élement i dans la liste score#
y=note_20[i] #La variable y est définit par l'élement i dans la liste note_sur20#
print("Le score",x,"est celui de",prenom[i],"est correspond à",y,"sur 20.")#Afficher le score selon le prénom#
Voici ce que donne le programme :
5) L'étape suivante que nous allons voir est un mélange de celle vu précedement qui sera plus approffondi.
Nous allons voir le calcul principal qui nous permet de convertir les scores pix en note sur 20. Cela donne donc :
for i in range(0,14,1): #boucle for pour la valeur i qui commencera de l'élément 0 à 13 ayant 1 de différence entre chaque éléments#
b=score[i] #La variable b est définit par l'élement i dans la liste score#
c=20 #La variable c est définit par 20 qui est la note maximale sur 20#
d=score_maximum(score) # La variable d est définit par la fonction du score maximum prenant score en paramètre#
a=b*c/d #La variable a est définit par le résultat de b multiplié par c le tout divisé par d#
note_sur20.append(round(a,2)) #On ajoute à la liste vide note_sur20 les résultats de la variable a qui sont arrondis à 2 chiffres après la virgule#
print("Le score",b,"est celui de",prenom[i],"est correspond à",round(a,2),"sur 20.") #Afficher le score de l'élève avec sa note sur 20#
print(note_sur20)#Afficher la liste note_sur20#
Voici ce que donne le programme :
6) Maintenant que nous avons tout ces éléments, il nous reste a faire le code qui fera un graphique des notes sur 20 de chaque élève. Le voici donc :
À la première ligne :
import matplotlib.pyplot as plt#On importe le dicionnaire permettant de faire des graphiques#
x=prenom #On défint à la varible x la liste prenom#
y=note_sur20 #On définit à la variable y la liste note_sur20#
plt.figure("Courbe des notes de pix sur 20 des élèves")#On nomme le graphique#
plt.plot(x, y)#On créé le graphique#
plt.xticks(rotation = 45)#On fait pivoter de 45° les étiquettes sur l'axe x#
plt.ylabel("Note sur 20")#On nomme l'axe des ordonnées#
plt.xlabel("Prénoms")#On nomme l'axe des abscisses#
plt.show()#On affiche la courbe#
Voici le programme complet :
Projet 2 :
1) Premièrement, voici le programme a compléter ci-dessous. Les lignes surlignées sont celles à compléter :
n = [] #
p = []
r = []
c = False
for i in range():
a = n[i]
b = p[i]
unite = (a and not(b) and not(c)) or\
(not(a) and b and not(c)) or\
(not(a) and not(b) and c) or\
(a and b and c)
r = [int(unite)] + r
c = (a and b) or (b and c) or (a and c)
r = + r
print(r)
a = "01010001"
b = "00110011"
sum = bin(int(a, 2) + int(b, 2))
print(sum[2:])
print (sum)
2) Ensuite, nous pouvons voir que étant donné que le programme écrit en dessous de print(r) a attribué à la valeur a = "01010001" et b = "00110011" alors nous pouvons donc les ajouter dans les listes n et p :
n = [0,1,0,1,0,0,0,1]
p = [0,0,1,1,0,0,1,1]
3) Nous savons également que pour effectuer une somme nous commençons par la droite du nombre. C'est pour cela que pour compléter la boucle for, il faut faire :
n = [0,1,0,1,0,0,0,1]
for i in range(7,-1,-1): #7 correspond au numéro de l'élément par lequel on commence, -1 correspond au dernier élément et le dernier -1 correspond à la différence entre chaque élément#
print(n[i])
Projet 3 :
1) Nous cherchons à savoir le temps que prend un programme a trier une liste mélangée. Pour cela, nous avons ajouter différent tris qui prennent plus ou moins de temps.
Voici le programme :
from time import *
import random
import matplotlib.pyplot as plt
import numpy as np
resultats_sort=[]
resultats_sorted=[]
resultats_tri_insertion=[]
resultats_tri_fusion=[]
resultats_tri_rapide=[]
resultats_tri_bulle=[]
resultats_tri_selection=[]
n_liste=[]
def creation_de_liste():
liste = []
n_liste.append(i*1000)
for k in range(i*1000):
liste.append(random.randint(0,100))
return liste
def duree_tri_sort(liste):
t1=time()
liste.sort()
t2=time()
duree=t2-t1
resultats_sort.append(duree)
random.shuffle(liste)
def duree_tri_sorted(liste):
t1=time()
liste_triee=sorted(liste)
t2=time()
duree=t2-t1
resultats_sorted.append(duree)
random.shuffle(liste)
def tri_insertion(liste):
for j in range (1,len(n_liste)):
key = liste[j]
i=j-1
while i>0 and liste[i]>key:
liste[i+1]=liste[i]
i=i-1
liste[i+1]=key
def duree_tri_insertion(liste):
t1=time()
tri_insertion(liste)
t2=time()
duree=t2-t1
resultats_tri_insertion.append(duree)
random.shuffle(liste)
def fusion(liste1,liste2):
liste=[]
i,j=0,0
while i<len(liste1)and j<len(liste2):
if liste1[i]<=liste2[j]:
liste.append(liste1[i])
i+=1
else:
liste.append(liste2[j])
j+=1
while i<len(liste1):
liste.append(liste1[i])
i+=1
while j<len(liste2):
liste.append(liste2[j])
j+=1
return liste
def tri_fusion(liste):
if len(liste)<2:
return liste[:]
else:
milieu=len(liste)//2
liste1=tri_fusion(liste[:milieu])
liste2=tri_fusion(liste[milieu:])
return fusion(liste1,liste2)
def duree_tri_fusion(liste):
t1=time()
tri_fusion(liste)
t2=time()
duree=t2-t1
resultats_tri_fusion.append(duree)
random.shuffle(liste)
def tri_rapide (liste):
def trirap(L, g, d):
pivot = L[(g+d)//2]
i = g
j = d
while True:
while L[i]<pivot:
i+=1
while L[j]>pivot:
j-=1
if i>j:
break
if i<j:
L[i], L[j] = L[j], L[i]
i+=1
j-=1
if g<j:
trirap(L,g,j)
if i<d:
trirap(L,i,d)
g=0
d=len(L)-1
trirap(L,g,d)
def duree_tri_rapide(liste):
t1=time()
tri_rapide(liste)
t2=time()
duree=t2-t1
resultats_tri_rapide.append(duree)
random.shuffle(liste)
def tri_bulle(liste):
n = len(liste)
for i in range(n):
for j in range(0, n-i-1):
if liste[j] > liste[j+1] :
liste[j], liste[j+1] = liste[j+1], liste[j]
def duree_tri_bulle(liste):
t1=time()
tri_bulle(liste)
t2=time()
duree=t2-t1
resultats_tri_bulle.append(duree)
random.shuffle(liste)
def tri_selection(liste):
for i in range(len(liste)):
min = i
for j in range(i+1, len(liste)):
if liste[min] > liste[j]:
min = j
tmp = liste[i]
liste[i] = liste[min]
liste[min] = tmp
return liste
def duree_tri_selection(liste):
t1=time()
tri_selection(liste)
t2=time()
duree=t2-t1
resultats_tri_selection.append(duree)
random.shuffle(liste)
for i in range(1,11):
print(i)
L= creation_de_liste()
duree_tri_sort(L)
duree_tri_sorted(L)
duree_tri_insertion(L)
duree_tri_fusion(L)
duree_tri_rapide(L)
duree_tri_bulle(L)
duree_tri_selection(L)
def tracer_figure(listesort,listesorted,listeinsertion,listefusion,listerapide,listebulle,listeselection,n_liste):
plt.figure(figsize = (16, 10))
plt.plot(n_liste,listesort,"o", label="sort", color="green",marker="o")
plt.plot(n_liste,listesorted,"o",label="sorted",color="red",marker="^")
plt.plot(n_liste,listeinsertion,"o",label="insertion",color="grey",marker="s")
plt.plot(n_liste,listefusion,"o",label="fusion",color="blue", marker="p")
plt.plot(n_liste,listerapide,"o",label="rapide",color="purple", marker="*")
plt.plot(n_liste,listebulle,"o",label="bulle",color="black", marker="v")
plt.plot(n_liste,listeselection,"o",label="selection",color="orange", marker="d")
plt.xlabel('n')
plt.ylabel('Durée')
plt.title("Durée versus n")
plt.legend()
plt.grid(True)
plt.show()
tracer_figure(resultats_sort,resultats_sorted,resultats_tri_insertion,resultats_tri_fusion,resultats_tri_rapide,resultats_tri_bulle,resultats_tri_selection,n_liste)
Voici d'abord toutes les importations de modules dans python nous permettant de tracer le futur graphique et d'ajouter à celui-ci un modèle
Ici, ce sont les listes vides créés qui seront ensuite remplies grâce à des fonctions.
On a définit une fonction créant une liste de 1000 éléments allant de 0 à 99.
On a définit une fonction calculant le temps d’exécution de sort qui trie la liste que l'on a définit dans la fonction plus tôt.
On définit une fonction duree_tri_sorted qui calculera le temps d'execution de sorted, puis rajoutera à la liste resultats_sorted. Après tout cela, elle remélangera la liste "liste".
On définit une fonction tri_insertion qui tri la liste en sortant les éléments d'une liste original puis de le réinsérer au bon emplacement.
On a définit une autre fonction, en lien avec celle d'au-dessus, qui permet de calculer la durée d’exécution de la fonction tri_insertion.
On définit une fonction pour la fusion, c'est-à-dire qui permet de diviser en deux moitiés la liste à trier pour ainsi trier les éléments dans chacune des listes et fusionner les deux moitiés obtenues pour reconstituer la liste triée.
On définit une autre fonction tri_fusion qui consiste à appliquer la fusion sur la liste du programme.
On définit une dernière fonction pour le tri par fusion qui cette fois, calcule la durée du tri fusion.
On définit la fonction tri_rapide qui permute des éléments pour les mettre dans l'ordre.
On définit une fonction qui calcule le temps d'exécution de la fonction tri_rapide.
On définit la fonction qui tri la liste en bulle c'est-à-dire qui comparer deux à deux les éléments consécutifs d'un tableau et d'effectuer une permutation si le premier élément est supérieur au deuxième.
On définit une fonction duree_tri_bulle qui calcule le temps d'exécution de la fonction précédente.
Ici, nous avons tout les paramètres pour créer un graphique. D'abord on a définit la fonction tracer_graphique qui prend en paramètre tout les tris que nous avons fait plus tôt. Les plt.plot, eux, permettent de changer la couleur de chacun, de les légender, ou de mettre des signes pour les différencier
On a définit une fonction de tri par sélection qui consiste à chercher le plus petit élément de la liste pour le mettre en premier, puis de repartir du second élément, et d'aller chercher le plus petit élément de la liste pour le mettre en second et ainsi de suite.
Maintenant, on définit la fonction qui va calculer la durée de l'exécution du tri par sélection.
On a créer une boucle qui va de 1 à 10 et qui permettra de savoir à combien de tours on est avant l'affichage du graphique. Ainsi on y retrouve toutes les fonctions calculant les durées de chaque tri.
Les remarques personnelles durant la création du programme :
Dans le programme, j'ai pu mettre pas mal de tris ce qui m'a valu parfois quelques petites erreurs mais qui peuvent être fatals si on ne les corrige pas. En effet, la programmation doit être parfaite, sans erreur, pour que le code marche. Par exemple, il met arriver de ne pas ajouter à la boucle for, une des durées de tri. Ainsi, je n'ai pas pu exécuter correctement mon programme. J'ai eu aussi, pour le programme à bulle notamment, quelques doutes sur le fait que mon programme marché puisque ça a ralenti mon temps d’exécution. Ainsi, quand j'ai pu voir que finalement mon programme marché, j'ai encore une fois douté puisque des tris étaient à une durée de 0 seconde. Or, j'ai appris plus tard que ce n'était pas une erreur mais un fait tout à fait normal puisque certains tris sont beaucoup plus lents que d'autres ce qui explique cette durée qui semble être à 0 seconde sur le graphique. Pour le dernier point, j'ai pu aussi voir avec mon professeur que les résultats de la fusion que j'ai inclus dans mon programme et de la fusion récursive que lui, a inclus dans le sien, ont des résultats différents puisque la fusion est plus rapide que la fusion récursive. Toutes ces problématiques m'ont appris à faire plus attention à ce que l'on pense être des détails, à relire mon travail et à continuer à douter pour mieux évoluer.
Voici le graphique que j'ai obtenu à l'exécution de mon programme python :
Voici un graphique de M.Laclaverie montrant bien les différents tris :
Conclusion :
Pour conclure, ce projet nous a permis de comprendre que les tris ont des durées d’exécution différents. Nous avons pu voir que le tri à bulle est l'algorithme le plus lent à la fois visible sur mon graphique comme celui du professeur, M.Laclaverie. Ensuite, suit le tri d'insertion, qui est lui-même suivit de prêt par le tri par sélection, avec peu de secondes d'intervalle. Pour le reste des tris, le temps est à 0 seconde puisque, comme j'ai pu le dire précédemment, les tris à bulle, d'insertion et de fusion sont beaucoup plus lents que les autres ce qui explique cette durée de 0 seconde qui n'est pas réellement le bon résultat. Ainsi, ces résultats nous amènent à penser que les tris les plus efficaces sont ceux ayant en durée 0 seconde. Or, si on enlève les tris les plus lents cités au dessus, et que l'on fait de nouveau exécuter le programme, les durées seront donc plus précises et nous permettront de voir qui est le programme le plus efficace entre le sort, le sorted ou le rapide. Finalement, nous pourrons voir qu'il s'agit du tri rapide qui est donc celui prenant le moins de temps.
Projet 4 :
Ce projet consistait à trouver un élément à classer en utilisant le k plus proche voisin à partir de deux programmes permettant pour l'un de déterminer la classe d'un élément et pour l'autre de faire un graphique de différents types d'éléments différenciés par des couleurs.
Voici le premier programme à utiliser :
positions_classes = [[1,"r"], [1.5,"t"], [3,"r"], [4,"t"], [5,"t"], [6,"r"], [7,"r"], [8,"t"], [10,"r"]]
x= 2
def distance (x1 : float,x2 : float) -> float :
'''calcule la valeur absolue de la distance entre x1 et x2'''
return abs(x2-x1)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],x),element[1]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
Voici le deuxième programme à utiliser :
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
Le programme suivant est celui que j'ai réussi à faire. Il ne donne pas le résultat attendu parce que la fonction déterminer un élément à classer n'est pas bien écrit.
import pandas
import matplotlib.pyplot as plt
import math
import pandas
import matplotlib.pyplot as plt
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range (150):
distances.append([distance(x[index], y[index], longueur, largeur), lab[index]])
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0 :
nombre_0=nombre_0+1
if distances[i][1] == 1 :
nombre_1=nombre_1+1
if distances[i][1] == 2 :
nombre_2=nombre_2+1
if nombre_0<nombre_1:
return " L'élement est un setosa "
if :
if nombre_0==nombre_1:
return " L'élément est un "
if
return " L'élement est un triangle "
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.legend()
plt.show()
Voici en-dessous le programme final, donné en correction par le professeur M. Laclaverie, qui donne le résultat est qui est une des propositions.
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
Conclusion :
Comme nous avons pu voir dans les différents programmes, mon problème a surtout était concerne
Projet 5 : Les survivants du Titanic
Ce projet commence par un programme qui nous est donné, calculant les survivants du Titanic selon différents éléments de condition, sous forme de graphique. Nous avons ces même conditions qui sont écrites sur un fichier csv, qui doit être au même endroit que le programme. Voici le programme en question.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
Lorsque l'on exécute ce programme, on obtient les différents graphiques.
Ce graphique montre le nombre de survivants selon la classe ( 1ère, 2ème ou 3ème ) des personnes. Nous pouvons voir que pour les personnes les plus riches, donc de 1ère classe, il y a plus de survivants, pour la deuxième classe, les survivants et les victimes sont presque au même niveau, il y a seulement un peu plus de victimes. Pour la classe la plus basse, il y a clairement plus de victimes ( plus de 350 ) que de survivants ( au alentour de 125 ).
Pour cet histogramme, 0 correspond aux femmes et 1 aux hommes. Il y beaucoup plus de victimes chez les hommes que chez les femmes qui elles ont majoritairement plus de survivantes.
Ici, nous avons un histogramme basé sur les âges. Nous pouvons voir que la plupart des morts sont autour de 20 à 30 ans même si pour chaque âge, à part les enfants entre 0 et 10 ans, il y a plus de morts que de survivants.
Ce graphique montre les statistiques selon le tarifs passagers cette fois. Nous pouvons constater que les personnes ayant le tarif le plus bas ont été le plus victimes du Titanic.
Ce graphique montre les personnes étant parents et enfants soient des familles à bord. Nous pouvons voir que les personnes étant seules ont étés clairement plus victimes tandis que ceux pouvant bénéficier d’entraide ont eu plus de chances et plus ont pu rester en vie.
Ce graphique montre les survivants selon le nombre de frères et sœurs et comme pour les familles,les personnes étant seules ont étés plus victimes tandis que ceux pouvant bénéficier d’entraide ont pu majoritairement rester en vie.
