#!/usr/bin/env python
# coding: utf-8

# # Projet 4 : Réaliser une étude de santé publique

#     

# ### Importation des librairies

# In[1]:


import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.cm as cm
get_ipython().run_line_magic('matplotlib', 'inline')


#    

# ### Importation des fichiers .csv

# In[2]:


dispo_alimentaire = pd.read_csv("C:/Users/solen/OneDrive/Documents/Formation Data Analyst OpenClassrooms/Projet 4/dispo_alimentaire.csv", encoding='UTF-8', sep =',')
print(dispo_alimentaire.head(5))


# In[3]:


insecurite_alimentaire = pd.read_csv("C:/Users/solen/OneDrive/Documents/Formation Data Analyst OpenClassrooms/Projet 4/sous_nutrition.csv", encoding='UTF-8', sep =',')
print(insecurite_alimentaire.head(5))


# In[4]:


aide_alimentaire = pd.read_csv("C:/Users/solen/OneDrive/Documents/Formation Data Analyst OpenClassrooms/Projet 4/aide_alimentaire.csv", encoding='UTF-8', sep =',')
print(aide_alimentaire.head(5))


# In[5]:


population = pd.read_csv("C:/Users/solen/OneDrive/Documents/Formation Data Analyst OpenClassrooms/Projet 4/population.csv", encoding='UTF-8', sep =',')
print(population.head(5))


#    

#     

# # Partie 1 : Requêtes de Marc sur les données de l'année 2017

#    

# ## 1) La proportion de personnes en état de sous-nutrition.

# In[6]:


# On affiche la première table dont on va avoir besoin pour repérer l'allure générale de nos données.

insecurite_alimentaire


# Interprétation de la première ligne : En 2013, en moyenne 8.6 millions de personnes étaient en sous-nutrition en Afghanistan.

# In[7]:


# Statistiques élémentaires des variables quantitatives pour le fichier Insecurite_alimentaire.

insecurite_alimentaire.describe()


# On observe qu'il y a 203 pays différents recensés dans la table.

# In[8]:


# On peut afficher les 203 pays en question pour se faire une première idée desquels on parle.

insecurite_alimentaire['Zone'].unique()


# In[9]:


# On calcule ensuite le taux moyen de valeurs manquantes pour les personnes en état de sous-nutrition.

insecurite_alimentaire.isna().mean()


# On constate que l'information est manquante pour quasiment la moitié de nos données, concernant le nombre de personnes (en millions d'habitants) qui ne mangent pas à leur faim.

# In[10]:


# On fait le choix de remplacer les valeurs manquantes NaN par des 0 grâce à la méthode .fillna().

insecurite_alimentaire["Valeur"].fillna(0, inplace = True)
 
insecurite_alimentaire


# Il est préférable de remplacer les valeurs manquantes par des 0 pour éviter de perdre trop d'informations, car le taux moyen de valeurs manquantes dans la table Insecurité_alimentaire est quand même proche des 50%. De plus, cela n'altère en rien les résultats des futurs calculs, de remplacer par 0 les valeurs manquantes.

# In[11]:


# On affiche les différentes valeurs possibles pour la colonne Année.

insecurite_alimentaire['Année'].unique()


# In[12]:


# On sélectionne dans la variable Année uniquement la période 2017 qui correspond à la valeur "2016-2018".

sous_nutrition_2017 = insecurite_alimentaire.loc[(insecurite_alimentaire['Année'] == '2016-2018'), :]
sous_nutrition_2017


# In[13]:


# On modifie le dataframe Sous_nutrition_2017 en renommant les valeurs "2016-2017" par "2017" en vue de la future jointure 
# avec la table Population_2017.

sous_nutrition_2017 = sous_nutrition_2017.replace(['2016-2018'], 2017)

print(sous_nutrition_2017)


# In[14]:


# Egalement, on remplace les valeurs (qui sont des chaînes de caractères) "< 0.1" par "0" dans le data frame Sous_nutrition_2017 
# pour pouvoir faire la future conversion de cette variable en float.

sous_nutrition_2017 = sous_nutrition_2017.replace(['<0.1'], 0)
print(sous_nutrition_2017)


# In[15]:


# On affiche le type de chacune des variables du data frame Sous_nutrition_2017.

sous_nutrition_2017.dtypes


# In[16]:


# Puis, on affiche les informations de la table Population.

print(population)


# In[17]:


# On convertit le nombre d'habitants en millions d'habitants.

population["Valeur"] *= 1000


# In[18]:


# On renomme dans la table Population, la variable "Valeur" par "Population" pour que cela soit plus explicite.

population.rename(columns={'Valeur': 'Population'}, inplace=True)
population


# In[19]:


# On sélectionne la population des pays qui concerne uniquement l'année 2017.

population_2017 = population.loc[(population['Année'] == 2017), :]
print(population_2017)


# In[20]:


# On réalise une jointure à droite entre les tables sous_nutrition_2017 et Population_2017 pour afficher l'ensemble des pays 
# de la table Population_2017 et ajouter à côté leurs valeurs associées si ce sont des pays en sous-nutrition.
# Sinon le tableau retournera des valeurs manquantes (NaN).

df = pd.merge(sous_nutrition_2017, population_2017, on = "Zone", how = 'right')
df.head()


# In[21]:


# On renomme les autres variables du data frame obtenu après la jointure pour une meilleure compréhension des variables.

df.rename(columns={'Année_x': 'Année Sous_nutrition'}, inplace=True)
df.rename(columns={'Valeur': 'Personnes sous-alimentées'}, inplace=True)
df.rename(columns={'Année_y': 'Année'}, inplace=True)
df


# In[22]:


# On fait un rappel du type de chacune des variables du data frame Df.

df.dtypes


# In[23]:


# On convertit la colonne "Personnes sous-alimentées" en décimaux (float) car elle est actuellement de type object 
# et il est donc impossible pour le moment d'appliquer des calculs arithmétiques sur des chaînes de caractères.

df['Personnes sous-alimentées'] = df['Personnes sous-alimentées'].astype(float)
df


# In[24]:


# On vérifie que la conversion s'est bien passée.

df.dtypes


# In[25]:


# On réalise une deuxième conversion, cette fois-ci pour la variable "Personnes sous-alimentées"

df['Personnes sous-alimentées'] = df['Personnes sous-alimentées']*1000000


# In[26]:


# Une fois le nettoyage des données effectué, on calcule la proportion demandée de personnes en sous-nutrition :

proportion_sous_nutrition = ((df['Personnes sous-alimentées'].sum() / df['Population'].sum())*100).round(2)
print("En 2017, la proportion de personnes en état de sous-nutrition dans le monde était de : ", proportion_sous_nutrition, '%')


# In[27]:


# On peut traduire ce résultat obtenu en pourcentage, en un nombre théorique :

somme_prs_en_sous_nutrition = df["Personnes sous-alimentées"].sum()
print("Il y a", somme_prs_en_sous_nutrition, "personnes qui souffraient de sous-nutrition parmi la population totale en 2017.")


#     

# ## 2) Le nombre théorique de personnes qui pourraient être nourries.

# In[28]:


dispo_alimentaire


# In[29]:


# Statistiques descriptives des variables QT

dispo_alimentaire.describe()


# Grâce à ce tableau, on peut observer dans un premier temps quelles sont les quantités minimales (min) et maximales (max) attribuées à chaque catégorie. Par exemple, dans la table, il y a au minimum aucune quantité d'aliments attribuées aux animaux dans un pays donné, et au maximum un autre pays peut attribuer 150 000 tonnes d'aliments disponibles à l'alimentation animale. 
# 
# Ensuite, "mean" donne la moyenne entre toutes les valeurs pour chaque variable en prenant en compte tous les pays.
# 
# Enfin, on a les quartiles dont chacune des trois valeurs sépare les données triées en quatre parts égales, de sorte que chaque partie représente un quart de l'échantillon de population.
# 
# Q1 est la valeur qui sépare les 25 % inférieurs des données ;   
# Ex : Pour quantité d'aliments disponibles (en tonnes) attribuée à l'alimentation humaine, 25% des valeurs sont égales à 0.
# 
# Q2 est la valeur qui sépare les 50 % inférieurs des données ;   
# Ex : Pour quantité d'aliments disponibles (en tonnes) attribuée à l'alimentation humaine, 50% des valeurs sont inférieures à 5 tonnes.
# 
# Q3 est la valeur qui sépare les 75 % inférieurs des données ;
# Ex : Pour quantité d'aliments disponibles (en tonnes) attribuée à l'alimentation humaine, 75% des valeurs sont inférieures à 52 tonnes.
# 

# In[30]:


# Taux de valeurs manquantes 

dispo_alimentaire.isna().mean()


# In[31]:


# On remplace les valeurs NaN par des 0 pour toutes les variables de la table où le taux de valeurs manquantes est positif.

dispo_alimentaire["Aliments pour animaux"].fillna(0, inplace = True)
dispo_alimentaire["Autres Utilisations"].fillna(0, inplace = True)
dispo_alimentaire["Disponibilité alimentaire (Kcal/personne/jour)"].fillna(0, inplace = True)
dispo_alimentaire["Disponibilité alimentaire en quantité (kg/personne/an)"].fillna(0, inplace = True)
dispo_alimentaire["Disponibilité de matière grasse en quantité (g/personne/jour)"].fillna(0, inplace = True)
dispo_alimentaire["Disponibilité de protéines en quantité (g/personne/jour)"].fillna(0, inplace = True)
dispo_alimentaire["Disponibilité intérieure"].fillna(0, inplace = True)
dispo_alimentaire["Exportations - Quantité"].fillna(0, inplace = True)
dispo_alimentaire["Importations - Quantité"].fillna(0, inplace = True)
dispo_alimentaire["Nourriture"].fillna(0, inplace = True)
dispo_alimentaire["Pertes"].fillna(0, inplace = True)
dispo_alimentaire["Production"].fillna(0, inplace = True)
dispo_alimentaire["Semences"].fillna(0, inplace = True)
dispo_alimentaire["Traitement"].fillna(0, inplace = True)
dispo_alimentaire["Variation de stock"].fillna(0, inplace = True)

dispo_alimentaire


# In[32]:


# On vérifie que le taux de valeurs manquantes pour chacune des variables de la table est désormais bien égal à 0.

dispo_alimentaire.isna().mean()


# In[33]:


# On affiche le type de chacune des variables du data frame.

dispo_alimentaire.dtypes


# In[34]:


# On crée une copie de la table originale pour ne pas faire les modifications directement sur celle-ci.

dispo_alim_copie = dispo_alimentaire.copy()


# In[35]:


# On va créer une nouvelle colonne correspondant à chaque variable d'origine dont l'unité est le millier de tonnes que l'on
# va convertir en kg. Puis on supprimera les anciennes colonnes.

dispo_alim_copie["Aliments pour animaux (kg)"] = dispo_alimentaire["Aliments pour animaux"]*1000000
dispo_alim_copie["Autres Utilisations (kg)"] = dispo_alimentaire["Autres Utilisations"]*1000000
dispo_alim_copie["Disponibilité intérieure en kg"] = dispo_alimentaire["Disponibilité intérieure"]*1000000
dispo_alim_copie["Exportations - Quantité (kg)"] = dispo_alimentaire["Exportations - Quantité"]*1000000
dispo_alim_copie["Nourriture (kg)"] = dispo_alimentaire["Nourriture"]*1000000
dispo_alim_copie["Pertes (kg)"] = dispo_alimentaire["Pertes"]*1000000
dispo_alim_copie["Production (kg)"] = dispo_alimentaire["Production"]*1000000
dispo_alim_copie["Semences (kg)"] = dispo_alimentaire["Semences"]*1000000
dispo_alim_copie["Traitement (kg)"] = dispo_alimentaire["Traitement"]*1000000
dispo_alim_copie["Variation de stock (kg)"] = dispo_alimentaire["Variation de stock"]*1000000


# In[36]:


# Autre façon de faire

# dispo_alimentaire.fillna(0, inplace=True)

# colonnes_tonnes_tokg = ['Aliments pour animaux', 'Disponibilité intérieure', 'Exportations - Quantité',
#                         'Importations - Quantité', 'Nourriture', 'Pertes', 'Production',
#                         'Semences', 'Traitement', 'Variation de stock', 'Autres Utilisations']

# for elt in colonnes_tonnes_tokg:
#     dispo_alimentaire[elt] *= 1000000


# In[37]:


dispo_alim_copie


# In[38]:


# Ensuite, on va supprimer les anciennes colonnes dont l'unité est le millier de tonnes.

dispo_alim_copie.drop(["Aliments pour animaux", "Autres Utilisations", "Disponibilité intérieure", "Exportations - Quantité", "Nourriture", "Pertes", "Production", "Semences", "Traitement", "Variation de stock"], axis = 1, inplace = True)
dispo_alim_copie.head(5)


# In[39]:


# Puis, on fait une jointure entre les tables Dispo_alim_copie et Population_2017 sur la colonne Zone (clé en commun dans les
# 2 tables) car on souhaiterait connaître le nombre total de personnes au monde qui pourraient être nourries pour l'année 2017.

df_dispo_alimentaire_bis = pd.merge(dispo_alim_copie, population_2017, on = "Zone", how = 'right')
df_dispo_alimentaire_bis


# In[40]:


# Pour obtenir la disponibilité totale (mondiale) en kcal 

df_dispo_alimentaire_bis["Dispo totale kcal"] = df_dispo_alimentaire_bis["Disponibilité alimentaire (Kcal/personne/jour)"]*df_dispo_alimentaire_bis["Population"]*365
df_dispo_alimentaire_bis


# In[41]:


somme_pop_nourries = df_dispo_alimentaire_bis['Dispo totale kcal'].sum()

print(f"La disponibilité alimentaire totale en kcal est de : {df_dispo_alimentaire_bis['Dispo totale kcal'].sum()}")


# Tous les êtres-humains n'ont pas besoin de la même quantité de kcal journalière pour vivre, donc on peut faire une moyenne entre celle d'une femme et celle d'un homme, et on arrondi au-dessus pour être plus large.
# 
# Le nombre de calories journaliers dont a besoin une femme est environ égal à 2220, et pour un homme c'est environ 2700 calories.
# J'ai donc fait la moyenne des deux et arrondi au-dessus, c'est-à-dire à 2500 calories par jour pour un être-humain.

# In[42]:


nb_theorique = somme_pop_nourries/(2500*365)

print("Le nombre théorique de personnes qui pourraient être nourries est de", round(nb_theorique,0), "personnes.")


#    

# ## 3) Le nombre théorique de personnes qui pourraient être nourries à partir de végétaux

# In[43]:


# On reprend le tableau précédent.

df_dispo_alimentaire_bis


# In[44]:


# On filtre pour n'afficher que les produits végétaux de disponibles. On stocke ce nouveau résultat dans un nouveau data frame.

dispo_alimentaire_vegetaux = df_dispo_alimentaire_bis.loc[(dispo_alimentaire['Origine'] == 'vegetale'), :]
dispo_alimentaire_vegetaux


# In[45]:


# On fait la somme de cette nouvelle variable créée.

somme_vegetaux_nourris = dispo_alimentaire_vegetaux['Dispo totale kcal'].sum()
somme_vegetaux_nourris


# In[46]:


# On calcule le nombre de personnes qui pourraient être nourries à partir du résultat précédent, et en divisant bien par 
# le nombre de kcal fixé et par le nombre de jours qu'il y a dans une année.

nb_theorique_total_vegetaux = somme_vegetaux_nourris/(2500*365)

print("En 2017, le nombre théorique de personnes qui pourraient être nourries à partir de produits végétaux est égal à", round(nb_theorique_total_vegetaux,0))


#     

# ## 4) L'utilisation de la disponibilité intérieure

# In[47]:


# On reprend la table dont les variables sont converties en kg.

dispo_alim_copie


#   

# In[48]:


# On commence par faire la somme totale de la disponibilité alimentaire de chacun des pays.

disponibilite_interieure = dispo_alim_copie["Disponibilité intérieure en kg"].sum()

print("Il y a", disponibilite_interieure, "kg d'aliments disponibles au total dans le monde.")


# ### La part de disponibilité intérieure attribuée à l'alimentation animale.

# In[49]:


# Puis, on fait la somme des disponibilités alimentaires dédiées aux animaux.

disponibilite_animale = dispo_alim_copie["Aliments pour animaux (kg)"].sum()

print("Il y a", disponibilite_animale, "kg d'aliments dédiés à l'alimentation animale.")


# In[50]:


# En fonction de la quantité de nourriture disponible pour les animaux, on calcule la proportion de la disponibilité intérieure
# attribuée à l'alimenttaion animale.

part_nourriture_dispo = round((disponibilite_animale/disponibilite_interieure)*100,2)

print("Dans le monde, il y a", part_nourriture_dispo, "% d'aliments dédiés à l'alimentation animale.")


#     

# ### La part de la disponibilité intérieure qui est perdue.

# In[51]:


# On calcule la quantité de pertes de la disponibilité intérieure.

quantite_perdue = dispo_alim_copie["Pertes (kg)"].sum()
print("Il y a", quantite_perdue, "kg d'aliments qui sont perdus.")


# In[52]:


# En fonction de la quantité de pertes d'aliments, on calcule la proportion d'aliments qui est perdue.

part_pertes_nourriture = round((quantite_perdue/disponibilite_interieure)*100,2)

print("Dans le monde, il y a", part_pertes_nourriture, "% d'aliments de perdus.")


#    

# ### La part de la disponibilité intérieure qui est attribuée à l'alimentation humaine.

# In[53]:


# On calcule la quantité de nourriture attribuée à l'alimentation humaine.

quantite_alimentation_humaine = dispo_alim_copie["Nourriture (kg)"].sum()

print("Il y a", quantite_alimentation_humaine, "kg d'aliments disponibles qui seront utilisés pour l'alimentation humaine.")


# In[54]:


# A partir du résultat précédent, on calcule la proportion d'aliments attribuée à l'alimentation humaine.

part_alimentation_humaine = round((quantite_alimentation_humaine/disponibilite_interieure)*100,2)

print("Dans le monde, il y a", part_alimentation_humaine, "% d'aliments utilisés pour l'alimentation humaine.")


#    

# ### La part de la disponibilité intérieure qui consacrée pour d'autres utilisations.

# In[55]:


# On calcule la quantité d'aliments utilisée pour d'autres usages.

quantite_alimentation_autres = dispo_alim_copie["Autres Utilisations (kg)"].sum()

print("Il y a", quantite_alimentation_autres, "kg d'aliments disponibles pour d'autres utilisations.")


# In[56]:


# A partir du résultat précédent, on calcule la proportion d'aliments attribués à d'autres usages que l'alimentation humaine, animale, ect...

part_alimentation_autres = round((quantite_alimentation_autres/disponibilite_interieure)*100,2)

print("Dans le monde, il y a", part_alimentation_autres, "% d'aliments qui sont attribués d'autres utilisations.")


#    

# ### Diagramme circulaire

# In[57]:


# Création d'une liste contenant les 3 parts de disponibilité intérieure calculées précédemment.
values = [part_nourriture_dispo, part_pertes_nourriture, part_alimentation_humaine, 32.64]

# Création d'une liste contenant le nom des étiquettes de données.
names = ['Alimentation animale', 'Pertes', 'Alimentation humaine', 'Autres']

# Création d'un data frame
data_piechart = pd.DataFrame(list(zip(names, values)), columns = ['Nom','Valeur'])

# On trie dans un ordre décroissant en fonction de la variable "Value"
data_dispo_interieure = data_piechart.sort_values('Valeur', ascending = False)
data_dispo_interieure


# In[58]:


import plotly.express as px

dataframe = px.data.tips()

fig = px.pie(data_dispo_interieure, title = 'Répartition de la gestion de la disponibilié intérieure mondiale en 2017', values='Valeur', names='Nom', color_discrete_sequence=px.colors.sequential.RdBu)

fig.update_traces(textposition='inside')
fig.update_layout(uniformtext_minsize=14, uniformtext_mode = 'hide')
fig.show()


# On constate que quasiment la moitié des aliments disponibles sont réservés à l'alimentation humaine. Suivi par celle réservée à d'autres usages (32.6%) (ex : le tourisme).
# 
# Egalement, on observe que seulement 13.2% des aliments disponibles sont utilisés pour nourrir les animaux.
# 
# Enfin, quasiment 5% des quantités alimentaires sont perdues/gaspillées.

#     

#    

# # Partie 2 : Les demandes de Mélanie

#    

# ## 1) Les pays pour lesquels la part de personnes sous-alimentées est la plus forte en 2017

# In[59]:


# On peut commencer par reprendre le dernier data frame obtenu (Df) en ajoutant une nouvelle colonne pour calculer la proportion 
# de personnes en sous-nutrition pour chaque ligne de la table.

df['Proportion_sous_nutrition'] = df['Personnes sous-alimentées'] / df['Population']
df


# In[60]:


# On affiche l'ensemble des valeurs uniques obtenues dans cette nouvelle variable.

df['Proportion_sous_nutrition'].unique()


# On constate qu'il y a des valeurs manquantes, donc on va les supprimer de la table.

# In[61]:


# Suppression des valeurs manquantes de la table.

df = df.dropna()
df


# On a donc supprimé 33 lignes.

# In[62]:


# On affiche le type de chacune des variables de la table.

df.dtypes


# Etant donné qu'on a fait précédemment une jointure entre les tables "Sous_nutrition_2017" et "Population_2017", il y a des pays pour lesquels la proportion de personnes en sous-nutrition est égale à 0.
# 
# Ainsi, pour afficher les 10 pays où la proportion est la plus forte, on va faire un tri décroissant de notre data frame, en fonction de la variable calculée : "Proportion_sous_nutrition" et n'afficher que les 10 premières lignes.

# In[63]:


# On stocke cela dans un nouveau data frame pour ne pas confondre avec ce qui a été fait précédemment.

df_pays_sous_nutrition = df.sort_values('Proportion_sous_nutrition', ascending = False).head(10)
df_pays_sous_nutrition


# In[64]:


# On renomme la République populaire démocratique de Corée par la "Corée du Nord" pour que le diagramme en barres ci-dessous 
# soit plus esthétique.

df_pays_sous_nutrition = df_pays_sous_nutrition.replace(["République populaire démocratique de Corée"], "Corée du Nord")
df_pays_sous_nutrition


# ### Diagramme en barres

# In[65]:


plt.figure(figsize = (8,6))

plt.xticks(rotation = '90')
plt.title("Les 10 pays les plus sous-alimentés dans le monde en 2017", fontsize = 11)
plt.xlabel('Pays émergents')
plt.ylabel('Pourcentage de personnes sous-alimentées (%)')
plt.bar(df_pays_sous_nutrition['Zone'],
        df_pays_sous_nutrition['Proportion_sous_nutrition'],
        color = cm.rainbow(np.linspace(0, 1, len(df_pays_sous_nutrition))),
        edgecolor = 'black')

ca = df_pays_sous_nutrition['Proportion_sous_nutrition'].tolist()

for i in range (10) :
    plt.text(i-0.35, ca[i]+0.007, round(ca[i], 3))
plt.show()


# Parmi ces 10 pays, on retrouve majoritairement des pays d'Afrique très marqués par la pauvreté dont le Tchad, le Mozambique et Madagascar, ainsi que d'autres pays du globe faisant partis des pays les plus pauvres au monde, comme Haïti et l'Afghanistan.
# 
# En 2017, à Haïti, 48.3% de la population souffrait de sous-nutrition. En effet, Haïti reste le pays le plus pauvre du continent Américain, selon la Banque mondiale, avec 60 % de sa population qui vit sous le seuil de pauvreté. Les enfants sont les premiers concernés par le manque de nourriture, et cela affecte fortement leur santé.
# 
# De plus, Haïti est marqué par une très forte instabilité politique et ne reçoit jamais les aides qui lui sont promises.
# 
# Egalement, la majorité de ces pays n'ont pas accès aux soins de base.
# 
# Enfin, pour le cas de Haïti et la Corée du Nord, ce sont des pays très vulnérables face aux catastrophes naturelles, donc il est
# difficile pour eux de reconstruire des insfrastructures par leurs manques de moyens/ressources. 
# 
# L'ensemble de ces facteurs impactent fortement la vie de ces habitants qui ont du mal à sortir de la pauvreté car ils vivent dans des conditions très difficiles et nécessitent que dépendent fortement des autres pays internationaux pour qu'ils leurs apportent des aides. 

#    

# ## 2) Les pays ayant bénéficié le plus d'aides depuis 2013

#    

# In[66]:


# On affiche le data frame dont on va avoir besoin.

aide_alimentaire


# In[67]:


# On va commencer par créer une copie de la table originale Aide_alimentaire.

aide_alimentaire_copie = aide_alimentaire.copy()


# In[68]:


# On affiche le type de chacune des variables du data frame.

aide_alimentaire_copie.dtypes


# In[69]:


# Puis on va créer une nouvelle colonne dans laquelle on va convertir la colonne Valeur en kg qui correspond initialement 
# à la quantité de tonnes d'aliments/de produits attribuée aux pays qui bénéficient d'aides.

aide_alimentaire_copie["Qté d'aliments reçue (en kg)"] = aide_alimentaire_copie["Valeur"]*1000
aide_alimentaire_copie


# In[70]:


# On supprime la colonne Valeur (en tonnes).

aide_alimentaire_copie.drop(["Valeur"], axis = 1, inplace = True)
aide_alimentaire_copie


# In[71]:


# On renomme la colonne Pays bénéficiaire par "Zone" pour homogénéiser avec les autres tables.

aide_alimentaire_copie.rename(columns={'Pays bénéficiaire': 'Zone'}, inplace=True)
aide_alimentaire_copie


# In[72]:


# Liste de tous les pays ayant bénéficié d'aides entre 2013 et 2016.

liste_pays_beneficiaires = aide_alimentaire_copie['Zone'].unique()
liste_pays_beneficiaires


# In[73]:


aide_alimentaire_copie['Année'].unique()


# On a pas l'année 2017 dans la table

# In[74]:


# On reprend le tableau précédent mais en ne prenant pas en compte les années.

aide_alimentaire_pays = aide_alimentaire_copie[['Zone', 'Produit', "Qté d'aliments reçue (en kg)"]]
aide_alimentaire_pays


# In[75]:


# Pour savoir quels pays a bénéficié le + d'aides, on va agréger les données en faisant un GROUP BY pour afficher la somme
# des aides perçue pour chaque pays distinct.

pays_beneficiaires = aide_alimentaire_pays.groupby('Zone').sum()
pays_beneficiaires


# In[76]:


# On trie ce tableau par ordre décroissant.

pays_beneficiaires = pays_beneficiaires.sort_values("Qté d'aliments reçue (en kg)", ascending = False).head(10)
pays_beneficiaires


# In[77]:


# On fait la somme totale des valeurs obtenues.

pays_beneficiaires_somme = pays_beneficiaires["Qté d'aliments reçue (en kg)"].sum()

print("Au total, les pays bénéficiaires d\'aides ont reçu au total", pays_beneficiaires_somme, "kg d'aliments.")


# In[78]:


# On tranforme les résultats obtenus en % pour que ce soit + parlant.

pays_beneficiaires['Pourcentage'] = round((pays_beneficiaires["Qté d'aliments reçue (en kg)"]/pays_beneficiaires_somme)*100,1)
pays_beneficiaires


# In[79]:


y = ['Niger','République démocratique du Congo','Somalie','Bangladesh','Kenya','Soudan','Soudan du Sud','Yémen','Éthiopie','République arabe syrienne']

x = [3.7, 3.8, 3.9,4.6,7.3,8.8, 9.2,15.9,18.2, 24.6, ]

colors = ["gainsboro", "lavender", "mistyrose", "peachpuff", "moccasin","wheat", "palegoldenrod", "lightcyan", "powderblue", "cadetblue"]

plt.figure(figsize = (10,6))

plt.barh (y, x, color = colors, edgecolor = 'black')

plt.ylabel("Pays bénéficiaires d'aides", color = "black")
plt.xlabel("Aides perçues (%)")
plt.title("Les 10 pays bénéficiant le plus d'aides dans le monde depuis 2013", fontsize = 12, fontweight = "bold")
    
plt.show()


# On retrouve essentiellement des pays en guerre et qui souffrent beaucoup de la pauvreté car ils ont très peu de ressources disponibles.
# 
# Parmi ces 10 pays, la République arabe syrienne perçoit 24.6% d'aides alimentaires, suivi de l'Ethiopie et du Yémen avec respectivement 18.2% et 15.9% d'aides perçues.
# 
# Malgré le fait que la Somalie, la République démocratique du Congo et le Niger, fassent partis des pays les plus pauvres au monde et vivent dans des conditions très difficiles, on constate que les aides qu'ils perçoivent, représentent pour chacun d'entre eux moins de 4% des aides totales reçues parmi ces 10 pays. 

#    

#    

# ## 3) Les pays ayant le plus et le moins de disponibilité par habitant.

# In[80]:


# On affiche le data frame que l'on va utilisée pour la suite.

df_dispo_alimentaire_bis


#    

# ### Aliments pour animaux + Autres utilisations + Semences + Traitement + Pertes = Disponibilité intérieure = Production + (Importations - Quantité) - (Exportations - Quantité) + Variation des stocks

# In[81]:


# On commence par afficher la disponibilité alimentaire pour chacun des pays.

dispo_par_habitant = df_dispo_alimentaire_bis[['Zone', 'Produit', 'Disponibilité alimentaire (Kcal/personne/jour)']].groupby(['Zone']).sum()
dispo_par_habitant


# ### Les 10 premiers pays dont la disponibilité alimentaire par habitant est la plus élevée.

# In[82]:


# On regarde dans un premier temps la disponibilité alimentaire par habitant la plus élevée pour les 10 premiers pays 

dispo_par_habitant_plus = dispo_par_habitant.loc[dispo_par_habitant["Disponibilité alimentaire (Kcal/personne/jour)"] != 0]
dispo_par_habitant_plus = dispo_par_habitant_plus.sort_values('Disponibilité alimentaire (Kcal/personne/jour)', ascending = False)
dispo_par_habitant_plus = dispo_par_habitant_plus.head(10)
dispo_par_habitant_plus


#    

# ### Représentation graphique

# In[83]:


# On crée une liste des 10 pays qui font partis de ceux ayant la disponibilité alimentaire la plus élevée parmi tous les pays du monde.

pays_plus_disponibilite = ["Autriche", "Belgique", "Turquie", "États-Unis d'Amérique", "Israël", "Irlande", "Italie", "Luxembourg", "Égypte", "Allemagne"]


# In[84]:


# On crée une seconde liste dans laquelle on stocke les valeurs de la variable "Disponibilité alimentaire (Kcal/personne/jour)".

liste_dispo_interieure = dispo_par_habitant_plus["Disponibilité alimentaire (Kcal/personne/jour)"].tolist()


# In[85]:


# On crée ensuite un un data frame dans lequel on va stocker les valeurs obtenues.
df_pays_1 = pd.DataFrame(list(zip(pays_plus_disponibilite,liste_dispo_interieure)), columns = ['Pays','Valeur'])

# On trie dans un ordre décroissant en fonction de la variable "Value"
data1 = df_pays_1.sort_values('Valeur', ascending = False)
data1


# In[86]:


# Diagramme en barres

plt.figure(figsize = (8,6))

colors = ["beige", "mistyrose", "antiquewhite", "honeydew", "powderblue", "skyblue","cadetblue", "steelblue", "cornflowerblue", "darkslategrey"]

plt.barh(pays_plus_disponibilite, liste_dispo_interieure, edgecolor = 'black', color = colors)

plt.ylabel("Pays", color = "black")
plt.xlabel("Disponibilité alimentaire par habitant (kcal)")
plt.title("Les 10 pays dont la disponibilité alimentaire par habitant est la plus élevée", fontsize = 12, fontweight = "bold")

plt.show()


# On peut lire qu’en Autriche, chaque habitant dispose par jour d’environ 3770 kcal pour se nourrir. On retrouve essentiellement des pays développés, situés en Europe (ex: Belgique, Italie, Irlande, Allemagne), et qui ont facilement accès à manger.

#   

#   

# ### Les 10 premiers pays dont la disponibilité alimentaire par habitant est la moins élevée.

# In[87]:


# On commence par afficher la disponibilité alimentaire en kcal par personne et par jour, en fonction de chaque pays et produit.

dispo_par_habitant = df_dispo_alimentaire_bis[['Zone', 'Produit', 'Disponibilité alimentaire (Kcal/personne/jour)']].groupby(['Zone']).sum()


# In[88]:


# Puis, on regarde celle qui est la moins élevée pour les 10 premiers pays.

dispo_par_habitant_moins = dispo_par_habitant.loc[dispo_par_habitant["Disponibilité alimentaire (Kcal/personne/jour)"] != 0]
dispo_par_habitant_moins = dispo_par_habitant_moins.sort_values('Disponibilité alimentaire (Kcal/personne/jour)')
dispo_par_habitant_moins = dispo_par_habitant_moins.head(10)
dispo_par_habitant_moins


#    

# ### Représentation graphique

# In[89]:


# On crée deux listes : 

# Une dans laquelle on stocke les 5 pays en question.
pays_moins_disponibilite = ["République centrafricaine", "Zambie", "Madagascar", "Afghanistan", "Haïti", "Corée du Nord", "Tchad", "Zimbabwe", "Ouganda", "Timor-Leste"]

# Une autre où on stocke les valeurs pour la disponibilité intérieure en kg de ces 5 pays.
liste_dispo_int_moins = dispo_par_habitant_moins["Disponibilité alimentaire (Kcal/personne/jour)"].tolist()


# In[90]:


# Création d'un data frame

df_pays_2 = pd.DataFrame(list(zip(pays_moins_disponibilite, liste_dispo_int_moins)), columns = ['Pays','Valeur'])

# On trie dans un ordre croissant en fonction de la variable "Valeur"
data2 = df_pays_2.sort_values('Valeur', ascending = True)
data2


# In[132]:


# Diagramme en barres

plt.figure(figsize = (8,6))

colors = ["seashell","wheat", "tan", "burlywood", "goldenrod", "rosybrown", "peru", "darkgoldenrod", "saddlebrown", "maroon"]

plt.barh (pays_moins_disponibilite, liste_dispo_int_moins, edgecolor = 'black', color = colors)

plt.ylabel("Pays", color = "black")
plt.xlabel("Disponibilité alimentaire par habitant (kcal)")
plt.title("Les 10 pays dont la disponibilité alimentaire par habitant est la plus faible", fontsize = 12, fontweight = "bold")

plt.show()


# On retrouve majoritairement des pays d'Afrique et notamment certains pays qui souffrent fortement de sous-nutrition : Haiti, la Corée du Nord, Madagascar, le Tchad, le Timor-Leste et l'Afghanistan. 
# 
# Par exemple, un habitant qui vit en Zambie doit se nourrir avec moins de 2000 kcal par jour, alors que la moyenne pour un être-humain est d'environ 2500 kcal.
# 
# Comme ce sont des pays très sous-alimentés, ils ne mangent pas à leur faim et mangent en-dessous de l'apport alimentaire journalier dont ils ont besoin.

#    

#   

# # Partie 3 : Les requêtes de Julien

#    

# ## 1) La répartition de l'utilisation des céréales

# In[92]:


# On commence par afficher la table dont on va avoir besoin pour la suite, et dont les variables sont converties en kg.

dispo_alim_copie


# Pour sélectionner quelles céréales j'allais stocker dans une liste, je suis allée sur le site de la FAO, et j'ai repris la liste des produits céréaliers que j'allais utiliser pour l'étude. 

# In[93]:


# Importation du fichier CSV contenant la liste de toutes les céréales à prendre en compte pour l'étude.

fao = pd.read_csv("C:/Users/solen/OneDrive/Documents/Formation Data Analyst OpenClassrooms/Projet 4/FAOSTAT.csv", sep =',')
print(fao.head(5))


# In[94]:


# On affiche l'ensemble des différents types céréales de la table.

fao["Produit"].unique()


# In[95]:


# On crée une liste dans laquelle on stocke tous les produits qui sont des céréales.

liste_céréales = fao["Produit"].unique()
liste_céréales


# In[96]:


# On crée un nouveau data frame dans lequel on ne garde que les produits qui sont contenus dans la liste des céréales.

df_cereales = dispo_alim_copie[dispo_alim_copie["Produit"].isin(liste_céréales)]
df_cereales


# In[97]:


# Ensuite, on ne garde que les variables qui nous intéressent.

df_cereale_monde = df_cereales[["Produit", "Disponibilité intérieure en kg", "Nourriture (kg)", "Aliments pour animaux (kg)", "Pertes (kg)", "Semences (kg)"]]
df_cereale_monde


# In[98]:


df_cereale_monde["Produit"].unique()


# On ne retrouve que 2 céréales en commun dans les 2 tables : les céréales et l’avoine, alors que dans la table des disponibilités alimentaires, on a plus de céréales disponibles. 
# 
# Donc, pour calculer la répartition des céréales, je me suis basée sur les céréales du fichier CSV disponible sur le site de la FAO.

#   

# ### Part de céréales utilisées pour l'alimentation humaine (%)

# In[99]:


proportion_cereales_humains = round(df_cereale_monde["Nourriture (kg)"].sum() / (df_cereale_monde["Disponibilité intérieure en kg"].sum()) *100, 1)

print("Il y a", proportion_cereales_humains, "% des céréales utilisées pour nourrir les êtres-humains.")


#    

# ### Part de céréales utilisées pour l'alimentation animale (%)

# In[100]:


proportion_cereales_animaux = round(df_cereale_monde["Aliments pour animaux (kg)"].sum() / (df_cereale_monde["Disponibilité intérieure en kg"].sum()) *100, 1)

print("Il y a", proportion_cereales_animaux, "% des céréales utilisées pour nourrir les animaux.")


#    

# ### Part de céréales qui est perdue (%)

# In[101]:


proportion_cereales_perdue = round(df_cereale_monde["Pertes (kg)"].sum() / (df_cereale_monde["Disponibilité intérieure en kg"].sum()) *100, 1)

print("Il y a", proportion_cereales_perdue, "% des céréales qui sont perdues.")


#    

# ### Part de céréales destinée aux semences (%)

# In[102]:


proportion_cereales_semences = round(df_cereale_monde["Semences (kg)"].sum() / (df_cereale_monde["Disponibilité intérieure en kg"].sum()) *100, 1)

print("Il y a", proportion_cereales_semences, "% des céréales utilisées pour les semences.")


#   

#    

# In[103]:


# Sommes des quantités de produits céréaliers qui sont dédiées à l'alimentation humaine, l'alimentation animale, les pertes
# et les autres utilisations

somme_cereales_nourriture = df_cereale_monde["Nourriture (kg)"].sum()
print("Il y a", somme_cereales_nourriture, "kg de produits céréaliers utilisés pour l'alimentation humaine.")

somme_cereales_animaux = df_cereale_monde["Aliments pour animaux (kg)"].sum()
print("Il y a", somme_cereales_animaux, "kg de produits céréaliers utilisés pour l'alimentation animale.")

somme_cereales_pertes = df_cereale_monde["Pertes (kg)"].sum()
print("Il y a", somme_cereales_pertes, "kg de produits céréaliers qui sont gaspillés.")

somme_cereales_semences = df_cereale_monde["Semences (kg)"].sum()
print("Il y a", somme_cereales_semences, "kg de produits céréaliers utilisés pour les semences.")


# ### Diagramme circulaire

# In[104]:


# Création d'une liste contenant les 3 parts de disponibilité intérieure calculées précédemment.
valeurs_cereales = [proportion_cereales_humains, proportion_cereales_perdue, proportion_cereales_animaux, proportion_cereales_semences, 20.80]

# Création d'une liste contenant le nom des étiquettes de données.
names = ['Alimentation humaine', 'Pertes', 'Alimentation animale', 'Semences', 'Autres']


# In[105]:


# Création d'un data frame

data_df = pd.DataFrame(list(zip(names,valeurs_cereales)), columns = ['Nom','Valeur'])

# On trie dans un ordre décroissant en fonction de la variable "Value"
data = data_df.sort_values('Valeur', ascending = False)
data


# In[106]:


import plotly.express as px

# Modifier la taille de la fenêtre graphique
plt.figure(figsize = (6,4))

dframe = px.data.tips()
fig = px.pie(data, title='Répartition de l\'utilisation des céréales (%)', values='Valeur', names='Nom', color = "Valeur")
fig.show()


# L’utilisation des céréales est assez bien répartie entre les différentes utilisations possibles, même si on retrouve quand même une part plus importante de céréales utilisées pour nourrir les êtres-humains qui représente presque 60% des données. Seulement 2.2% des céréales disponibles sont perdues.

#    

# ## Idée additionnelle : L'utilisation des 3 principales céréales : le blé, le riz et le maïs

# J'ai fait une analyse plus approfondie sur la répartition des céréales utilisées, en utilisant cette fois-ci 
# celles issues du fichier des disponibilités alimentaires.
# 
# J'ai donc étudié pour les trois céréales les plus utilisées, la répartition de celles-ci utilisées pour l'alimentation humaine, 
# l'alimentation animale et les pertes. 

# In[107]:


dispo_alim_copie


# In[108]:


# On crée une liste dans laquelle on stocke l'ensemble des céréales présentes dans le fichier des disponibilités alimentaires

liste_céréales_bis = ['Maïs', 'Riz (Eq Blanchi)', 'Millet', 'Avoine', 'Soja', 'Orge', 'Blé', 'Seigle', 'Céréales, Autres', 'Sorgho']


# In[109]:


# On crée un nouveau data frame dans lequel on ne garde que les produits qui sont contenus dans la liste "liste_céréales".

df_cereales_bis = dispo_alim_copie[dispo_alim_copie["Produit"].isin(liste_céréales_bis)]
df_cereales_bis


# In[110]:


# On vérifie cette fois-ci qu'on a bien plus de choix de céréales que précédemment.

df_cereales_bis["Produit"].unique()


# In[111]:


# On regroupe par céréales le data frame précédent.

df_cereales_bis = df_cereales_bis.groupby("Produit").sum()
df_cereales_bis


# In[112]:


# On fait la somme pour chacune des catégories.

somme_nourriture_humaine = df_cereales_bis["Nourriture (kg)"].sum()
print("Il y a", somme_nourriture_humaine, "kg de nourriture dédiés à l'alimentation humaine.")

somme_aliments_animaux = df_cereales_bis["Aliments pour animaux (kg)"].sum()
print("Il y a", somme_aliments_animaux, "kg d'aliments attribués à l'alimentation animale.")

somme_autres_utilisations = df_cereales_bis["Autres Utilisations (kg)"].sum()
print("Il y a", somme_autres_utilisations, "kg d'aliments qui servent pour d'autres utilisations.")

somme_pertes = df_cereales_bis["Pertes (kg)"].sum()
print("Il y a", somme_pertes, "kg de nourriture de perdue.")

somme_semences = df_cereales_bis["Semences (kg)"].sum()
print("Il y a", somme_semences, "kg d'aliments pour les semences.")

somme_traitements = df_cereales_bis["Traitement (kg)"].sum()
print("Il y a", somme_traitements, "kg d'aliments dédiés aux traitements.")


# In[113]:


# On transforme les résultats obtenus dans le tableau en pourcentage pour que ce soit + parlant.

df_cereales_bis["Nourriture (%)"] = round((df_cereales_bis["Nourriture (kg)"]/somme_nourriture_humaine)*100,2)
df_cereales_bis["Aliment pour animaux (%)"] = round((df_cereales_bis["Aliments pour animaux (kg)"]/somme_aliments_animaux)*100,2)
df_cereales_bis["Autres Utilisations (%)"] = round((df_cereales_bis["Autres Utilisations (kg)"]/somme_autres_utilisations)*100,2)
df_cereales_bis["Pertes (%)"] = round((df_cereales_bis["Pertes (kg)"]/somme_pertes)*100,2)
df_cereales_bis["Semences (%)"] = round((df_cereales_bis["Semences (kg)"]/somme_semences)*100,2)
df_cereales_bis["Traitement (%)"] = round((df_cereales_bis["Traitement (kg)"]/somme_traitements)*100,2)

df_cereales_bis


# In[114]:


# Ensuite, on ne garde que les variables qui nous intéressent.

df_cereales_bis = df_cereales_bis[["Nourriture (%)", "Aliment pour animaux (%)", "Autres Utilisations (%)", "Pertes (%)", "Semences (%)", "Traitement (%)"]]
df_cereales_bis


# In[115]:


# Ensuite, on stocke dans 3 variables différentes les valeurs qui nous intéressent et que l'on souhaite faire apparaître dans
# notre pie chart.

# Nourriture destinée à l'alimentation humaine
nourriture_ble = df_cereales_bis.iloc[1,0] # 44.04
nourriture_riz = df_cereales_bis.iloc[6,0] # 36.29
nourriture_mais = df_cereales_bis.iloc[3,0] # 12.04

# Aliments destinés à l'alimentation animale
animaux_mais = df_cereales_bis.iloc[3,1] # 61.29
animaux_ble = df_cereales_bis.iloc[1,1] # 14.55
animaux_orge = df_cereales_bis.iloc[5,1] # 10.40

animaux_riz = df_cereales_bis.iloc[6,1] # 3.77

# Quantité de céréales perdue
pertes_mais = df_cereales_bis.iloc[3,3] # 36.64
pertes_ble = df_cereales_bis.iloc[1,3] # 24.78
pertes_riz = df_cereales_bis.iloc[6,3] # 24.64


# ### Diagramme en barres

# In[116]:


import numpy as np
import matplotlib.pyplot as plt

N = 3
ind = np.arange(N) 
width = 0.30      

fig = plt.figure()
ax = fig.add_subplot(111)

blé = [nourriture_ble, animaux_ble, pertes_ble]
rects1 = ax.bar(ind, blé, width, color = 'olivedrab', edgecolor = 'black')

mais = [nourriture_mais, animaux_mais, pertes_mais]
rects2 = ax.bar(ind + width, mais, width, color = 'khaki', edgecolor = 'black')

riz = [nourriture_riz, animaux_riz, pertes_riz]
rects3 = ax.bar(ind + width*2, riz, width, color = 'darkseagreen', edgecolor = 'black')

ax.set_ylabel('Pourcentage')
ax.set_xticks(ind+width)
ax.set_xticklabels(('Alimentation humaine', 'Animaux', 'Pertes'))
ax.legend((rects1[0], rects2[0], rects3[0]), ('Blé', 'Maïs', 'Riz'))

plt.title("Répartition de la part des principales céréales utilisées pour l'alimentation humaine et animale, ainsi que les pertes (%)")

plt.show()


# On observe que la céréale la plus utilisée pour l'alimentation humaine est le blé (44.04%), suivi du riz (36.29%). 
# 
# On peut noter aussi que les parts perdues de blé et de riz sont plus importantes que celles utilisées pour nourrir les animaux.
# 
# Concernant les animaux, la céréale nettement privilégiée pour les nourrir est le maïs (61.29%).
# 
# Enfin, on constate qu'il y a quand même une part importante de céréales perdues, qui n'est pas négligeable. 
# Il y a quasiment autant de blé que de riz de perdu (respectivement 24.78% et 24.64%). 

#    

#   

# ## 2) L'utilisation du manioc en Thaïlande

# In[117]:


# On filtre le fichier des disponibilités alimentaires pour n'afficher que les informations concernant la Thaïlande.

dispo_alimentaire_thaïlande = dispo_alim_copie.loc[(dispo_alim_copie['Zone'] == 'Thaïlande'), :]
dispo_alimentaire_thaïlande


# In[118]:


# On filtre une nouvelle fois pour n'afficher que les produits qui sont du manioc.

dispo_alimentaire_thaïlande = dispo_alimentaire_thaïlande[(dispo_alimentaire_thaïlande['Zone'] == "Thaïlande") & 
                                                          (dispo_alimentaire_thaïlande['Produit'] == "Manioc")]
dispo_alimentaire_thaïlande


# La Thaïlande produit 30 228 000 000 kg de manioc dont 25 214 000 000 kg sont destinés à l'exportation.

# In[119]:


# On affiche le nombre de personnes (en milliers d'habitants) en sous-nutrition en Thaïlande pour chaque période.

sous_nutrition_Thaïlande = insecurite_alimentaire.dropna()
sous_nutrition_Thaïlande = sous_nutrition_Thaïlande.replace(["<0.1"],0)
sous_nutrition_Thaïlande = sous_nutrition_Thaïlande[(sous_nutrition_Thaïlande['Zone'] == "Thaïlande")]
sous_nutrition_Thaïlande['Valeur'] = sous_nutrition_Thaïlande['Valeur'].astype(float) *1000000
sous_nutrition_Thaïlande


# Par exemple, 6 200 000 de Thaïlandais étaient en sous-nutrition, en 2017

#   

# ### La proportion de Thaïlandais en sous-nutrition en 2017

# In[120]:


# On reprend le data frame Df, précédemment utilisé pour calculer la proportion de personnes en sous-nutrition pour chacun 
# des pays du monde.

df


# In[121]:


# On filtre ce data frame pour récupérer la ligne correspondant à la proportion de personnes en sous-nutrition en Thaïlande.

thai = df.loc[df['Zone'] == 'Thaïlande',:]

thailande = thai.iloc[0, 5]
thailande = round(thailande*100, 2)

print('En 2017, la proportion de personnes en sous-nutrition en Thaïlande était de :', thailande, "%")


# In[122]:


thai = df.loc[df['Zone'] == 'Thaïlande',:]
thai


#   

# ### En Thaïlande, la proportion de manioc exportée

# In[123]:


# On reprend le data frame spécifique à la Thaïlande et l'utilisation du manioc.

dispo_alimentaire_thaïlande


# In[124]:


# On calcule la proportion de manioc exportée à partir de la proportion de manioc produite.

thailande_manioc = dispo_alimentaire_thaïlande['Exportations - Quantité (kg)'].iloc[0]*100 / dispo_alimentaire_thaïlande['Production (kg)'].iloc[0]
thailande_manioc = round(thailande_manioc,2)
print("La Thaïlande exporte", thailande_manioc, "% de sa production de manioc.")


#   

# En 2017, la Thaïlande exportait donc 83.51% de sa production de manioc, sachant que presque 9% de sa population souffrait de faim. La Thaïlande est le premier pays producteur de manioc dans le monde, mais le manioc à lui tout seul ne peut pas résoudre le gros problème de famine dans le pays. Et, la population thaïlandaise ne peut pas se nourrir que de manioc.
# 
# Les principaux autres Etats producteurs de manioc dans le monde sont le Nigeria, la RDC, la Thaïlande, le Ghana et l'Indonésie.
# 
# Puis, au début du 21ème siècle, le manioc est devenu un aliment majeur au sein des pays en développement, en particulier en Afrique et en Amérique. En effet, le manioc occupe la 3ème place en tant que source de glucides alimentaires dans les tropiques, après le riz et le maïs. 
# 
# Donc, on peut penser que la Thaïlande préfère se tourner vers une agriculture intensive de ses productions alimentaires (accroître sa production agricole grâce à des facteurs de production : les surfaces cultivées, le travail et les équipements) pour que ses habitants aient accès aux productions de différentes personnes dans le pays.
# 
# De plus, la Thaïlande ne souhaite peut-être pas forcément recevoir de l'aide au niveau alimentaire car en plus du manioc, elle produit du coton, du maïs, le sorgho, la canne à sucre, le tabac, le soja, le café, la noix de coco, ect... Elle préfèrerait peut-être recevoir de l'aide pour construire/aménager des infrastructures (routes, écoles, hôpitaux...). 
# On peut donc aider/soutenir un pays en difficultés autrement qu'en lui donnant de la nourriture. Certains pays en développement n'ont donc pas tant de mal à produire des aliments, mais c'est au niveau des constructions de bâtiments/infrastructures qu'ils manquent davantage de moyens.

# In[125]:


aide_alimentaire_copie


# In[126]:


aide_alimentaire_copie['Zone'].unique()


# La Thailande ne perçoit pas d'aide alimentaire.

#    

#    

# ## Idée additionnelle : La répartition des produits distribués

# In[127]:


aide_alimentaire_copie


# In[128]:


# On commence par grouper par les produits. 

aide_alimentaire_bis = aide_alimentaire_copie.groupby('Produit').sum()

# On affiche les résultats que pour la colonne Valeur (Qté attribuée en tonnes comme aide alimentaire).

aide_alimentaire_bis = aide_alimentaire_bis[['Qté d\'aliments reçue (en kg)']]

# Tri décroissant

aide_alimentaire_bis = aide_alimentaire_bis.sort_values('Qté d\'aliments reçue (en kg)', ascending = False)

# Somme totale de la quantité alimentaire attribuée (en tonne)

somme_qte_alimentaire = aide_alimentaire_bis["Qté d\'aliments reçue (en kg)"].sum()
print("Il y a", somme_qte_alimentaire, "kg d'aliments confondus qu'ont reçu les pays bénéficiaires d'aides")

# Affichage en proportion

aide_alimentaire_bis["Proportion (%) de qté alimentaire attribuée"] = round((aide_alimentaire_bis['Qté d\'aliments reçue (en kg)']/somme_qte_alimentaire)*100, 2)
aide_alimentaire_bis


#    

# In[129]:


aide_alimentaire_graph = aide_alimentaire_bis.head(8)
aide_alimentaire_graph


# In[130]:


# Création du graphique

yy = ["Céréales", "Blé et Farin", "Non-céréales", "Céréales secondaires", "Riz", "Légumineuses Sèches", "Mélanges et préparations", "Huiles végétales"]
couleurs = ['SteelBlue', 'LightSkyBlue', 'SkyBlue',  'LightBlue', 'LightCyan', 'Azure', 'NavajoWhite', 'LightYellow']

plt.figure (figsize = (8,6))
plt.xticks(rotation = '90')
plt.title ("La part des produits distribués comme aides alimentaires (%)", fontname = 'Arial', fontsize = 13, fontweight = "bold")
plt.xlabel ("Produit", color = "black", fontsize = 10)
plt.ylabel ("Part de produit attribuée (%)", color = "black", fontsize = 10)
plt.bar(height = aide_alimentaire_graph['Proportion (%) de qté alimentaire attribuée'], x = yy, edgecolor = 'black', color = couleurs)

aa = aide_alimentaire_graph['Proportion (%) de qté alimentaire attribuée'].tolist()

for i in range (8) :
    plt.text(i-0.20, aa[i]+0.5, round(aa[i], 1))
plt.show()


# Les aliments dont reçoivent le plus les pays défavorisés sont majoritairement des céréales, du blé et de la farine. 
# La distribution des céréales représente environ 38.6% des aides alimentaires.