def ajout_pays(self, contenu):
"""Cette méthode permet d'ajouter un pays comme la précédente méthode ajout_section"""
gestionnaire = Gestionnaire()
donnees = Data_Base().donnees
noms_indisponibles = [Pays(num_pays, donnees).get_name() for num_pays in range(len(donnees)) if Pays(num_pays, donnees).get_name()]
if self.verification_connexion():
nom_pays = input('\nEntrez le nom du pays à ajouter :\n> ')
if nom_pays == 'none':
input("\nVous ne pouvez pas nommer un pays 'none'.\nAppyez sur entrer pour continuer.")
return self.afficher_pays(contenu)
if nom_pays in noms_indisponibles:
input('\nCe pays est déjà dans la liste.\nAppyez sur entrer pour continuer.')
return self.afficher_pays(contenu)
confirmation = input("\nConfirmation de l'ajout du pays (O/N) ?\n> ")
if confirmation not in ["o","O"]:
input("\nEchec de l'ajout du pays.\nAppyez sur entrer pour continuer.")
return self.afficher_pays(contenu)
donnees.append({})
nouveau_pays = Pays(len(donnees)-1, donnees)
nouveau_pays.set_name(nom_pays)
nouveau_pays.set_infos_de_base()
gestionnaire.update(nouveau_pays.donnees)
input("\nLe pays a bien été ajouté.\nAppuyez sur entrer pour continuer.")
return self.afficher_pays(contenu)
def somme(self):
"""Cette méthode renvoie un data frame d'une colonne. Elle fait la somme
des différents critères sur les pays."""
donnees = Data_Base().donnees
superficie_tot = sum([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'superficie')
])
population_tot = sum([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'population')
])
dette_tot = sum([
elm[0] for elm in self.liste_triee_selon_critere(donnees, 'dette')
])
criteres = [
"La somme des superficies de tous les pays",
"La somme des populations de tous les pays",
"La somme des dettes de tous les pays"
]
index = criteres
valeurs = [[superficie_tot], [population_tot], [dette_tot]]
return pandas.DataFrame(valeurs, index=criteres, columns=[''])
def _decider_correction(self, contenu, prop_cor):
"""Cette méthode permet au géographe de choisir entre valider ou refuser
une proposition de correction."""
donnees = Data_Base().donnees
gestionnaire = Gestionnaire()
try :
section_du_texte = Section(prop_cor.num_pays, donnees, prop_cor.chemin_prop)
except :
input('\nIl semble que la donnée initiale a été supprimée. Cette proposition va alors être supprimée.\nAppuyez sur entrer pour continuer')
gestionnaire.suppr_elm(prop_cor)
return self.gestion_corrections(contenu)
print("\nTexte actuel :\n")
print(section_du_texte.contenu["text"] + "\n")
print("Proposition de correction :\n")
print(prop_cor.txt_prop + "\n")
while True:
validation = input("Voulez-vous valider cette proposition de correction (V : valider / R : refuser / P : aucune action) ?\n> ")
if validation in ["v","V","r","R","p","P"]:
break
else :
input("\nVotre réponse doit être V, R ou P.\nAppyez sur entrer pour continuer.\n")
if validation in ['v', 'V']:
self._valider_prop(prop_cor, section_du_texte)
if validation in ['r', 'R']:
self._refuser_prop(prop_cor)
return self.gestion_corrections(contenu)
def sup_inf_seuil(self, critere, seuil):
donnees = Data_Base().donnees
liste_triee_selon_critere = self.liste_triee_selon_critere(
donnees, critere)
liste_triee_selon_critere.reverse()
pays_sup_seuil = []
pays_inf_seuil = []
col = ['PAYS', critere.upper()]
for elm in liste_triee_selon_critere:
if elm[0] >= seuil:
pays_sup_seuil.append([
elm[1].get_name(),
self.simplification(elm[1].get_critere(critere))
])
else:
pays_inf_seuil.append([
elm[1].get_name(),
self.simplification(elm[1].get_critere(critere))
])
tableau_pays_sup = pandas.DataFrame(
pays_sup_seuil,
index=[i + 1 for i in range(len(pays_sup_seuil))],
columns=col)
tableau_pays_inf = pandas.DataFrame(
pays_inf_seuil,
index=[i + 1 for i in range(len(pays_inf_seuil))],
columns=col)
return (len(pays_sup_seuil), tableau_pays_sup, len(pays_inf_seuil),
tableau_pays_inf)
def supprimer_pays(self, contenu):
gestionnaire = Gestionnaire()
donnees = Data_Base().donnees
noms_pays = [
Pays(num_pays, donnees).get_name()
for num_pays in range(len(donnees))
]
if self.verification_connexion():
nom_pays_a_supprimer = input(
'\nEntrez le nom du pays à supprimer\n> ')
if nom_pays_a_supprimer not in noms_pays:
input(
"\nCe pays n'existe pas.\nAppuyez sur entrer pour continuer."
)
return self.afficher_pays(contenu)
else:
num_pays_a_supprimer = noms_pays.index(nom_pays_a_supprimer)
confirmation = input(
"\nConfirmation de la suppression du pays (O/N) ? #Cela supprimera aussi toutes ses données#\n> "
)
if confirmation in ["o", "O"]:
del donnees[num_pays_a_supprimer]
gestionnaire.update(donnees)
input(
"\nLe pays a bien été supprimée.\nAppuyez sur entrer pour continuer."
)
else:
input(
"\nVotre tentative de suppression n'a pas abouti.\nAppuyez sur entrer pour continuer."
)
return self.afficher_pays(contenu)
def top_and_flop(self, critere, taille_classement):
donnees = Data_Base().donnees
liste_triee_selon_critere = self.liste_triee_selon_critere(
donnees, critere)
top = []
flop = []
rang_top = range(1, taille_classement + 1)
rang_flop = [
len(liste_triee_selon_critere) - i
for i in range(taille_classement)
]
col = ['PAYS', critere.upper()]
for i in range(taille_classement):
top.append([
liste_triee_selon_critere[-i - 1][1].get_name(),
self.simplification(
liste_triee_selon_critere[-i - 1][1].get_critere(critere))
])
flop.append([
liste_triee_selon_critere[i][1].get_name(),
self.simplification(
liste_triee_selon_critere[i][1].get_critere(critere))
])
return (pandas.DataFrame(top, index=rang_top, columns=col),
pandas.DataFrame(flop, index=rang_flop, columns=col))
def top_and_flop(self, critere, taille_classement):
"""Cette méthode renvoie deux data frames.
Le premier correspond aux 'taille_classement'(entier) premiers pays selon un certain critère.
Le second data frame correspond aux 'taille_classement'(entier) dernier pays selon un certain critère."""
donnees = Data_Base().donnees
liste_triee_selon_critere = self.liste_triee_selon_critere(
donnees, critere)
top = []
flop = []
rang_top = range(1, taille_classement + 1)
rang_flop = [
len(liste_triee_selon_critere) - i
for i in range(taille_classement)
]
col = ['PAYS', critere.upper()]
for i in range(taille_classement):
top.append([
liste_triee_selon_critere[-i - 1][1].get_name(),
self.simplification(
liste_triee_selon_critere[-i - 1][1].get_critere(critere))
])
flop.append([
liste_triee_selon_critere[i][1].get_name(),
self.simplification(
liste_triee_selon_critere[i][1].get_critere(critere))
])
return (pandas.DataFrame(top, index=rang_top, columns=col),
pandas.DataFrame(flop, index=rang_flop, columns=col))
def summary(self):
"""La méthode summary renvoie un data frame donnant des statistiques sur les différents critères (nombres de valeurs, moyenne, écart-type, ...)
mais uniquement sur les colonnes numériques. Pour cela, la méthode crée un dictionnaire où chaque clé correspond à un critère
que l'on associe à un data frame. Enfin, on utilise la méthode describe de pandas pour avoir notre résumé statistique."""
donnees = Data_Base().donnees
superficie = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'superficie')
])
population = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'population')
])
croissance_demographique = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'croissance démographique')
])
inflation = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'inflation')
])
dette = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(donnees, 'dette')
])
chomage = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'chômage')
])
depenses_sante = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'dépenses santé')
])
depenses_éducation = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'dépenses éducation')
])
depenses_militaires = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'dépenses militaires')
])
dic = {
'Superficie': superficie,
'Population': population,
'Croissance démo': croissance_demographique,
'Inflation': inflation,
'Dette': dette,
'Chômage': chomage,
'Dépenses santé': depenses_sante,
'Dépenses éducation': depenses_éducation,
'Dépenses militaires': depenses_militaires
}
return pandas.DataFrame(dic).describe()
def afficher_section(self, section, contenu):
donnees = Data_Base().donnees
num_pays = section.num_pays
chemin = section.chemin
choix_section = {}
chemin_a_afficher = Pays(section.num_pays, donnees).get_name()
for partie in chemin:
chemin_a_afficher += ' -> {}'.format(partie)
if section.is_section_de_texte():
print('\n{} :\n'.format(chemin_a_afficher))
print(section.contenu['text'])
self.correction(choix_section, section)
return self.afficher_section(Section(num_pays, donnees, chemin[:-1]), contenu)
sous_sections = section.get_noms_sous_sections()
if len(sous_sections) == 0:
choix_section['question'] = '{}\n\nCette section est vide.'.format(chemin_a_afficher)
else :
choix_section['question'] = '{}\n\nChoisissez une option.'.format(chemin_a_afficher)
choix_section['individu'] = contenu['individu']
choix_section['options'] = sous_sections
choix_section['options basiques'] = []
choix_section['actions'] = []
for partie in sous_sections:
nouveau_chemin = chemin + [partie]
choix_section['actions'].append((lambda contenu, nouveau_chemin=nouveau_chemin : self.afficher_section(Section(num_pays, donnees, nouveau_chemin), contenu)))
if self.statut == 'g' or self.statut == 'a':
if len(sous_sections) == 0:
choix_section['options basiques'].append(['AJOUTER UN TEXTE', 'AT'])
choix_section['actions'].append(lambda var : self.ajout_texte(contenu, section))
choix_section['options basiques'].append(['AJOUTER UNE SECTION', 'AS'])
choix_section['actions'].append(lambda var : self.ajout_section(contenu, section))
if self.statut == 'a' and len(sous_sections) != 0:
choix_section['options basiques'].append(['SUPPRIMER UNE SECTION', 'S'])
choix_section['actions'].append(lambda var : self.supprimer_section(contenu, section))
choix_section['options basiques'].append(['RETOUR', 'R'])
if len(chemin) == 0:
choix_section['actions'].append(lambda var : self.afficher_pays(contenu))
else:
choix_section['actions'].append(lambda var : self.afficher_section(Section(num_pays, donnees, chemin[:-1]), contenu))
choix_section['options basiques'].append(["RETOUR AU MENU DE L'ACTEUR", 'RMA'])
choix_section['actions'].append(lambda contenu : Menu_Ouvert(self.contenu_initial))
choix_section['options basiques'].append(['QUITTER', 'Q'])
choix_section['actions'].append(self.quitter)
return Menu_Ouvert(choix_section)
def diagramme_en_barres(self, critere):
donnees = Data_Base().donnees
liste_triee_selon_critere = self.liste_triee_selon_critere(
donnees, critere)
liste_triee = [elm[0] for elm in liste_triee_selon_critere]
x = [
self.simplification(elm[1].get_name())
for elm in liste_triee_selon_critere
]
plt.barh(x, liste_triee, color='b')
plt.yticks(fontsize=3.2)
plt.show()
def summary(self):
donnees = Data_Base().donnees
superficie = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'superficie')
])
population = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'population')
])
croissance_demographique = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'croissance démographique')
])
inflation = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'inflation')
])
dette = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(donnees, 'dette')
])
chomage = pandas.Series([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'chômage')
])
depenses_sante = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'dépenses santé')
])
depenses_éducation = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'dépenses éducation')
])
depenses_militaires = pandas.Series([
elm[0] for elm in self.liste_triee_selon_critere(
donnees, 'dépenses militaires')
])
dic = {
'Superficie': superficie,
'Population': population,
'Croissance démo': croissance_demographique,
'Inflation': inflation,
'Dette': dette,
'Chômage': chomage,
'Dépenses santé': depenses_sante,
'Dépenses éducation': depenses_éducation,
'Dépenses militaires': depenses_militaires
}
return pandas.DataFrame(dic).describe()
def clustering(self, nb_clusters):
"""Cette méthode utilise la méthode des Kmeans pour permettre à la fonction de créer des classes entre les pays.
Elle prend en argument le nombre de classes que l'utilisateur veut former.
Cette méthode renvoie un data frame où chaque colonne correspond à chaque classe
avec le nom des pays dans celles ci."""
donnees = Data_Base().donnees
criteres = [
'superficie', 'population', 'croissance démographique',
'inflation', 'dette', 'chômage', 'dépenses santé',
'dépenses éducation', 'dépenses militaires'
]
valeurs_pays = []
liste_des_pays_comptabilises = []
for num_pays in range(len(donnees)):
pays = Pays(num_pays, donnees)
if pays.get_name():
if True not in [
self.numerisation_critere(pays, critere) == 'NA'
for critere in criteres
]:
liste_des_pays_comptabilises.append(
self.simplification(pays.get_name()))
valeurs_pays.append([
self.numerisation_critere(pays, critere)
for critere in criteres
])
clf = KMeans(n_clusters=nb_clusters)
clf.fit(np.array(valeurs_pays))
labels = clf.labels_
pays_dans_clusters = [[] for i in range(nb_clusters)]
for i in range(len(labels)):
for cl in range(nb_clusters):
if labels[i] == cl:
pays_dans_clusters[cl].append(
liste_des_pays_comptabilises[i])
for cluster in pays_dans_clusters:
while len(cluster) < max([len(cl) for cl in pays_dans_clusters]):
cluster.append('')
liste_des_clusters = [
'Cluster {}'.format(i + 1) for i in range(nb_clusters)
]
return pandas.DataFrame(pays_dans_clusters, index=liste_des_clusters).T
def diagramme_en_barres(self, critere):
"""Cette méthode crée un diagramme en barres selon un critère choisi par le data scientist"""
donnees = Data_Base().donnees
liste_triee_selon_critere = self.liste_triee_selon_critere(
donnees, critere)
liste_triee = [elm[0] for elm in liste_triee_selon_critere]
x = [
self.simplification(elm[1].get_name())
for elm in liste_triee_selon_critere
]
plt.barh(x, liste_triee, color='b')
plt.yticks(fontsize=3.2)
plt.show()
def clustering(self, nb_clusters):
donnees = Data_Base().donnees
criteres = [
'superficie', 'population', 'croissance démographique',
'inflation', 'dette', 'chômage', 'dépenses santé',
'dépenses éducation', 'dépenses militaires'
]
valeurs_pays = []
liste_des_pays_comptabilises = []
for num_pays in range(len(donnees)):
pays = Pays(num_pays, donnees)
if pays.get_name():
if True not in [
self.numerisation_critere(pays, critere) == 'NA'
for critere in criteres
]:
liste_des_pays_comptabilises.append(
self.simplification(pays.get_name()))
valeurs_pays.append([
self.numerisation_critere(pays, critere)
for critere in criteres
])
clf = KMeans(n_clusters=nb_clusters)
clf.fit(np.array(valeurs_pays))
labels = clf.labels_
pays_dans_clusters = [[] for i in range(nb_clusters)]
for i in range(len(labels)):
for cl in range(nb_clusters):
if labels[i] == cl:
pays_dans_clusters[cl].append(
liste_des_pays_comptabilises[i])
for cluster in pays_dans_clusters:
while len(cluster) < max([len(cl) for cl in pays_dans_clusters]):
cluster.append('')
liste_des_clusters = [
'Cluster {}'.format(i + 1) for i in range(nb_clusters)
]
return pandas.DataFrame(pays_dans_clusters, index=liste_des_clusters).T
def afficher_pays(self, contenu):
""" Cette méthode permet au consultant d'afficher la liste des différents pays
et d'en choisir un par le nombre correspondant au pays affiché dans le menu"""
if self.contenu_initial == {}:
self.contenu_initial = contenu
donnees = Data_Base().donnees
nb_pays = len(donnees)
choix_pays = {}
choix_pays['question'] = 'Choisissez un pays.'
choix_pays['individu'] = contenu['individu']
liste_des_pays = []
for num_pays in range(nb_pays):
nom_pays = Pays(num_pays, donnees).get_name()
if nom_pays:
liste_des_pays.append((nom_pays, num_pays))
liste_des_pays.sort()
liste_des_noms = [pays[0] for pays in liste_des_pays]
liste_des_nums = [pays[1] for pays in liste_des_pays]
choix_pays['options'] = liste_des_noms
choix_pays['options basiques'] = []
choix_pays['actions'] = [
lambda var, num=num: self.afficher_section(Section(
num, donnees), contenu) for num in liste_des_nums
]
if self.statut == 'g' or self.statut == 'a':
choix_pays['options basiques'].append(['AJOUTER UN PAYS', 'A'])
choix_pays['actions'].append(lambda var: self.ajout_pays(contenu))
if self.statut == 'a':
choix_pays['options basiques'].append(['SUPPRIMER UN PAYS', 'S'])
choix_pays['actions'].append(
lambda var: self.supprimer_pays(contenu))
choix_pays['options basiques'].append(
["RETOUR AU MENU DE L'ACTEUR", 'R'])
choix_pays['actions'].append(
lambda var: Menu_Ouvert(self.contenu_initial))
choix_pays['options basiques'].append(['QUITTER', 'Q'])
choix_pays['actions'].append(self.quitter)
return Menu_Ouvert(choix_pays)
def _ajout_pays_table_criteres(self, contenu, liste_pays_a_afficher,
fonction_a_appliquer):
"""Cette méthode permet d'ajouter un pays à une liste afin d'appliquer une autre méthode
en fonction d'un certain critère. Cette méthode est utilisée par la fonction critere_usuel."""
donnees = Data_Base().donnees
nb_pays = len(donnees)
if len(liste_pays_a_afficher) >= 10:
input(
"\nVous ne pouvez pas afficher plus de 10 pays à la fois.\nAppuyez sur entrer pour continuer."
)
return fonction_a_appliquer(contenu, liste_pays_a_afficher)
choix_pays = {}
choix_pays['question'] = 'Choisissez un pays.'
choix_pays['individu'] = contenu['individu']
choix_pays['pseudo'] = contenu['pseudo']
liste_des_pays = []
liste_des_nums_pays_a_afficher = [
pays.num_pays for pays in liste_pays_a_afficher
]
liste_des_noms_pays_a_afficher = [
pays.get_name() for pays in liste_pays_a_afficher
]
for num_pays in range(nb_pays):
nom_pays = Pays(num_pays, donnees).get_name()
if nom_pays and nom_pays not in liste_des_noms_pays_a_afficher:
liste_des_pays.append((nom_pays, num_pays))
liste_des_pays.sort()
liste_des_noms = [pays[0] for pays in liste_des_pays]
liste_des_nums = [pays[1] for pays in liste_des_pays]
choix_pays['options'] = liste_des_noms
choix_pays['options basiques'] = []
choix_pays['actions'] = [
lambda var, num=num: fonction_a_appliquer(
contenu, liste_pays_a_afficher + [Pays(num, donnees)])
for num in liste_des_nums
if num not in liste_des_nums_pays_a_afficher
]
return Menu_Ouvert(choix_pays)
def boites_a_moustache(self):
"""Cette méthode crée une boîte à moustache sur les différentes classes d'ages."""
donnees = Data_Base().donnees
classe_age_0 = []
classe_age_1 = []
classe_age_2 = []
classe_age_3 = []
classe_age_4 = []
for num_pays in range(len(donnees)):
pays = Pays(num_pays, donnees)
if pays.get_name():
if self.numerisation_critere(pays, '0-14') != 'NA':
classe_age_0.append(self.numerisation_critere(
pays, '0-14'))
if self.numerisation_critere(pays, '15-24') != 'NA':
classe_age_1.append(
self.numerisation_critere(pays, '15-24'))
if self.numerisation_critere(pays, '25-54') != 'NA':
classe_age_2.append(
self.numerisation_critere(pays, '25-54'))
if self.numerisation_critere(pays, '55-64') != 'NA':
classe_age_3.append(
self.numerisation_critere(pays, '55-64'))
if self.numerisation_critere(pays, '>=65') != 'NA':
classe_age_4.append(self.numerisation_critere(
pays, '>=65'))
plt.title(
"Box-plots correspondants aux répartitions des valeurs des 5 classes d’âge pour tous les pays."
)
plt.boxplot([
classe_age_0, classe_age_1, classe_age_2, classe_age_3,
classe_age_4
],
labels=[
"0-14 years", "15-24 years", "25-54 years",
"55-64 years", ">=65"
])
plt.show()
def somme(self):
donnees = Data_Base().donnees
superficie_tot = sum([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'superficie')
])
population_tot = sum([
elm[0]
for elm in self.liste_triee_selon_critere(donnees, 'population')
])
dette_tot = sum([
elm[0] for elm in self.liste_triee_selon_critere(donnees, 'dette')
])
criteres = [
"La somme des superficies de tous les pays",
"La somme des populations de tous les pays",
"La somme des dettes de tous les pays"
]
index = criteres
valeurs = [[superficie_tot], [population_tot], [dette_tot]]
return pandas.DataFrame(valeurs, index=criteres, columns=[''])
def sup_inf_seuil(self, critere, seuil):
"""Cette méthode crée deux tableaux. Elle prend en argument un critère et un seuil.
La premier tableau correspond aux pays dépassant le seuil déterminé par l'utilisateur.
Le second correspond aux pays sous ce seuil. Elle renvoie 4 informations :
le nombre de pays dépassant le seuil avec le tableau des pays correspondant avec les valeurs de ce critère,
et le nombre de pays ne dépassant pas le seuil avec le tableau des pays correspondant avec les valeurs de ce critère"""
donnees = Data_Base().donnees
liste_triee_selon_critere = self.liste_triee_selon_critere(
donnees, critere)
liste_triee_selon_critere.reverse()
pays_sup_seuil = []
pays_inf_seuil = []
col = ['PAYS', critere.upper()]
for elm in liste_triee_selon_critere:
if elm[0] >= seuil:
pays_sup_seuil.append([
elm[1].get_name(),
self.simplification(elm[1].get_critere(critere))
])
else:
pays_inf_seuil.append([
elm[1].get_name(),
self.simplification(elm[1].get_critere(critere))
])
tableau_pays_sup = pandas.DataFrame(
pays_sup_seuil,
index=[i + 1 for i in range(len(pays_sup_seuil))],
columns=col)
tableau_pays_inf = pandas.DataFrame(
pays_inf_seuil,
index=[i + 1 for i in range(len(pays_inf_seuil))],
columns=col)
return (len(pays_sup_seuil), tableau_pays_sup, len(pays_inf_seuil),
tableau_pays_inf)
def __str__(self): donnees = Data_Base().donnees res = Pays(self.num_pays, donnees).get_name() + '/' for i in range(len(self.chemin_prop)): res += self.chemin_prop[i] + '/' return res
