Loading [MathJax]/jax/output/CommonHTML/fonts/TeX/fontdata.js

Projet 7 - Effectuez une prédiction de revenus

▪ Mission 1 : Résumé des données

▪ Mission 2 : Diversité des revenus et indice de Gini

Table des matières

• • • Paramètres config
• Préparation des données
  • 1. Distribution des revenus
  • 2. Indices de Gini
  • 3. Population
• Mission 1 : Résumé des données initiales
  • Périmètre temporel et spatial de l'analyse
  • Données concernant l'indice de Gini
  • Données démographiques
  • Type de quantiles utilisés
  • Unité $PPP
• Mission 2 : Diversité des revenus et indices de Gini
  • Calcul des indices de Gini
  • Cartes mondiales des indices de gini
  • Diversité des pays en terme de distribution des revenus
  • Courbes de Lorenz
  • Evolution de l'indice de Gini
    • Sur les années de l'analyse (2004-2011)
    • Sur toutes les années disponibles
  • Classement des pays par indice de Gini
  • Carte mondiale des indices de Gini (valeur moyenne)
• Export des données

Paramètres config

import warnings

def fxn():
    warnings.warn("deprecated", DeprecationWarning)

with warnings.catch_warnings():
    warnings.simplefilter("ignore")
    fxn()
    # importations de modules "local"
    import sys
    sys.path.append('functions/')
    import base_notebook_light
    import css_base_light
    import fonctions_perso

# import des librairies et des paramètres 
from base_notebook_light import *
from css_base_light import *

# repère de début de traitement pour calculer le temps tital d'exécution du notebook
start_time_m4 = time.time()

Préparation des données

• On importe les données initiales

1. Distribution des revenus

income_data = pd.read_csv("data/inputs/data-projet7.csv", decimal=",")
income_data

	country	year_survey	quantile	nb_quantiles	income	gdpppp
0	ALB	2008	1	100	728.89795	7297.00000
1	ALB	2008	2	100	916.66235	7297.00000
2	ALB	2008	3	100	1010.91600	7297.00000
3	ALB	2008	4	100	1086.90780	7297.00000
4	ALB	2008	5	100	1132.69970	7297.00000
...	...	...	...	...	...	...
11594	COD	2008	96	100	810.62330	303.19305
11595	COD	2008	97	100	911.78340	303.19305
11596	COD	2008	98	100	1057.80740	303.19305
11597	COD	2008	99	100	1286.60290	303.19305
11598	COD	2008	100	100	2243.12260	303.19305

11599 rows × 6 columns

# On vérifie le format des variables
income_data.dtypes

country          object
year_survey       int64
quantile          int64
nb_quantiles      int64
income          float64
gdpppp          float64
dtype: object

# On se familiarise avec les données
income_data.info()
income_data.describe().round(2)

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 11599 entries, 0 to 11598
Data columns (total 6 columns):
 #   Column        Non-Null Count  Dtype  
---  ------        --------------  -----  
 0   country       11599 non-null  object 
 1   year_survey   11599 non-null  int64  
 2   quantile      11599 non-null  int64  
 3   nb_quantiles  11599 non-null  int64  
 4   income        11599 non-null  float64
 5   gdpppp        11399 non-null  float64
dtypes: float64(2), int64(3), object(1)
memory usage: 543.8+ KB

	year_survey	quantile	nb_quantiles	income	gdpppp
count	11599.00	11599.00	11599.0	11599.00	11399.00
mean	2007.98	50.50	100.0	6069.22	50221.28
std	0.91	28.87	0.0	9414.19	400068.75
min	2004.00	1.00	100.0	16.72	303.19
25%	2008.00	25.50	100.0	900.69	2576.00
50%	2008.00	51.00	100.0	2403.24	7560.00
75%	2008.00	75.50	100.0	7515.42	18773.00
max	2011.00	100.00	100.0	176928.55	4300332.00

# La valeur max de 'gdpppp' parait très élevée
inc_temp = income_data[['country', 'year_survey', 'gdpppp']].drop_duplicates().sort_values(by='gdpppp', ascending=False)
inc_temp.head(5)

	country	year_survey	gdpppp
3200	FJI	2008	4300332.0
6299	LUX	2008	73127.0
8099	NOR	2008	49070.0
10899	USA	2008	43261.0
4500	IRL	2008	39268.0

# Verification sur le site de la Banque Mondiale (code FJI : code alpha3 des îles Fidji) -> valeur gdpppp 2008 : 7777.7
# Rq : La base PPP devant être plus récente sur le site, les valeurs sont surévaluées / notre jeu de données

# nouvelle valeur
gdp_fji_2008 = 7777.1/1.1

# modification de la valeur dans le df income_data
income_data.loc[(income_data['country'] == 'FJI') & (income_data['year_survey'] == 2008), 'gdpppp'] = gdp_fji_2008

# verification
income_data[(income_data['country'] == 'FJI') & (income_data['year_survey'] == 2008)].sample(1)

	country	year_survey	quantile	nb_quantiles	income	gdpppp
3297	FJI	2008	98	100	7265.1255	7070.090909

inc_temp = income_data[['country', 'quantile', 'year_survey', 'income']].drop_duplicates().sort_values(by='income', ascending=False)
inc_temp.head(5)

	country	quantile	year_survey	income
10998	USA	100	2008	176928.550
4899	ISL	100	2008	160645.270
3499	GBR	100	2008	141565.230
1599	CAN	100	2008	133454.840
3399	FRA	100	2008	122775.164

# On regarde si 'nb_quantiles' et 'year_survey' prennent plusieurs valeurs
income_data.nb_quantiles.nunique()
income_data.year_survey.nunique()

1

7

# On supprime la colonne 'nb_quantiles'
income_data=income_data.drop(columns='nb_quantiles')

# On détermine les différentes valeurs prises par year_survey
y=sorted(income_data.year_survey.unique())
y

[2004, 2006, 2007, 2008, 2009, 2010, 2011]

for year in y:
    df = income_data[income_data['year_survey'] == year]
    print(f"Année {year} : {df.shape[0]} éléments")

Année 2004 : 100 éléments
Année 2006 : 500 éléments
Année 2007 : 1500 éléments
Année 2008 : 7599 éléments
Année 2009 : 1200 éléments
Année 2010 : 600 éléments
Année 2011 : 100 éléments

pays_inc_year={}
for year in y:
    pays_inc_year[year]=income_data[income_data['year_survey'] == year]['country'].unique()
pays_inc_year

{2004: array(['SYR'], dtype=object),
 2006: array(['GHA', 'PHL', 'THA', 'VEN', 'VNM'], dtype=object),
 2007: array(['BIH', 'BTN', 'CHN', 'CMR', 'GIN', 'IND', 'KEN', 'LAO', 'LBR',
        'LKA', 'MAR', 'MNG', 'NER', 'TLS', 'TZA'], dtype=object),
 2008: array(['ALB', 'ARG', 'ARM', 'AUT', 'AZE', 'BEL', 'BGR', 'BLR', 'BOL',
        'BRA', 'CAF', 'CAN', 'CIV', 'COL', 'CRI', 'CYP', 'CZE', 'DEU',
        'DNK', 'DOM', 'ECU', 'ESP', 'EST', 'FIN', 'FJI', 'FRA', 'GBR',
        'GEO', 'GRC', 'HND', 'HRV', 'HUN', 'IRL', 'IRN', 'IRQ', 'ISL',
        'ISR', 'ITA', 'JOR', 'JPN', 'KAZ', 'KGZ', 'KHM', 'KOR', 'XKX',
        'LTU', 'LUX', 'LVA', 'MDA', 'MEX', 'MKD', 'MNE', 'MOZ', 'MRT',
        'NLD', 'NOR', 'PAK', 'PER', 'POL', 'PRT', 'PRY', 'ROU', 'RUS',
        'SLV', 'SRB', 'SVK', 'SVN', 'SWE', 'TUR', 'TWN', 'UKR', 'URY',
        'USA', 'YEM', 'ZAF', 'COD'], dtype=object),
 2009: array(['BFA', 'CHL', 'EGY', 'IDN', 'MYS', 'NIC', 'PAN', 'SDN', 'SWZ',
        'TJK', 'UGA', 'PSE'], dtype=object),
 2010: array(['BGD', 'MDG', 'MLI', 'MWI', 'NGA', 'NPL'], dtype=object),
 2011: array(['GTM'], dtype=object)}

• Nombre de lignes
  11 599 lignes dans le df data ; or il y a 100 quantiles par pays
  -> il manque donc un quantile pour un pays

# on récupère la liste des pays
l_country = list(set(income_data.country.tolist()))

# on cherche le pays qui n'a pas 100 entrées
for i in l_country:
    if income_data.groupby('country').size()[i] != 100:
        print(i)
        pays_cible = i

LTU

# on vérifie que ce pays n'a que 99 entrées
income_data.groupby('country').size()['LTU']

99

# on cherche le quantile manquant :
#### on crée une liste de référence l_liste allant de 1 à 100
#### on compare la liste des quantiles du pays_cible à la liste de référence

# liste de réf
l_ref=np.arange(1, 101, 1)

# liste pays_cible
df_pays_cible = income_data[income_data['country'] == pays_cible]
l_pays_cible = df_pays_cible['quantile'].tolist()

# comparaison des 2 listes
q_manquant = set(list(l_ref)) - set(list(l_pays_cible))
q_manquant = list(q_manquant)[0]


print(f" Ainsi, il manque le quantile {q_manquant} au pays {pays_cible}")

 Ainsi, il manque le quantile 41 au pays LTU

# On vérifie qu'il manque 200 valeurs à la variable 'gdpppp'
income_data.isna().sum()

country          0
year_survey      0
quantile         0
income           0
gdpppp         200
dtype: int64

# on cherche les pays correspondant aux NaN
print(income_data[income_data['gdpppp'].isna()].country.unique())

['XKX' 'PSE']

• Il manque le centile 41 pour le pays 'LTU'
• Les données concernant la variable gdpppp sont absentes pour 2 pays (2 x 100 = 200) : 'XKX' et 'PSE'

On va chercher les pays correspondants à ces sigles.
On va pour cela se servir d'une table de correspondance code_pays / nom_pays, par exemple celle présente sur le site sql.sh

code_corr_pays = pd.read_csv("data/inputs/sql-pays.csv")
code_corr_pays.head(2)

	id	code	alpha2	alpha3	nom_pays_fr	nomp_pays_en
0	1	4	AF	AFG	Afghanistan	Afghanistan
1	2	8	AL	ALB	Albanie	Albania

code_p = ['LTU', 'XKX', 'PSE']
for code in code_p:
    pays = code_corr_pays[code_corr_pays['alpha3'] == code]["nom_pays_fr"].values[0]
    print(f"{code} : {pays}")

LTU : Lituanie
XKX : Kosovo
PSE : Territoire Palestinien Occupé

Traitement de 'XKX' et de 'PSE'

Les infos trouvées sur le site de la banque mondiale permettent de faire une estimation du gdpppp pour l'année 2008

# En comparant, pour des pays dont on dispose du gdppp, avec les valeurs dispo sur le site de la banque mondiale,
# on obtient approximativement les mêmes valeurs en divisant par 1.1

# Calcul du gdpppp pour le Kosovo
gdp_xkx = 7249.5/1.1

# Calcul du gdppp pour PSE ("Cisjordanie et Gaza" dans la dénomination Banque Mondiale)
gdp_pse = 1020/1.1

# Insert des valeurs dans le df income_data
income_data.loc[income_data['country'] == 'XKX', 'gdpppp'] = gdp_xkx
income_data.loc[income_data['country'] == 'PSE', 'gdpppp'] = gdp_pse

# Verif de l'absence de valeurs nulles
income_data.isna().sum()

country        0
year_survey    0
quantile       0
income         0
gdpppp         0
dtype: int64

Traitement de 'LTU'

On va estimer la valeur manquante pour le centile 41 grâce à la méthode interpolate
Rq : on garde la méthode linéaire (méthode pa défaut)

# on ajoute une ligne au df data sans renseigner 'income' (donc NaN)
income_data=income_data.append({'country': 'LTU', 
             'year_survey': 2008,
             'quantile': 41,
             'gdpppp': 17571.0
            }, ignore_index=True)

income_data=income_data.sort_values(by=["country", "quantile"])
income_data=income_data.reset_index(drop=True)
income_data.head(3)

	country	year_survey	quantile	income	gdpppp
0	ALB	2008	1	728.89795	7297.0
1	ALB	2008	2	916.66235	7297.0
2	ALB	2008	3	1010.91600	7297.0

# estimation du NaN avec interpolate()
income_ltu = income_data[income_data['country'] == 'LTU'][['quantile', 'income']]
income_ltu = income_ltu.interpolate()
income_ltu[38:45]

	quantile	income
6238	39	4802.36800
6239	40	4868.45070
6240	41	4882.14065
6241	42	4895.83060
6242	43	4950.63800
6243	44	5006.78600
6244	45	5028.54440

# on remplace le NaN par la valeur estimée
val = income_ltu.loc[income_ltu['quantile'] == 41, 'income'].values[0]
income_data.loc[(income_data['country'] == 'LTU') & (income_data['quantile'] == 41), 'income'] = val
income_data.loc[(income_data['country'] == 'LTU') & (income_data['quantile'] > 38) & (income_data['quantile'] < 44)]

	country	year_survey	quantile	income	gdpppp
6238	LTU	2008	39	4802.36800	17571.0
6239	LTU	2008	40	4868.45070	17571.0
6240	LTU	2008	41	4882.14065	17571.0
6241	LTU	2008	42	4895.83060	17571.0
6242	LTU	2008	43	4950.63800	17571.0

Haut de page    

2. Indices de Gini

# On importe et on visualise les données
gini_data_all=pd.read_csv("data/inputs/gini_bq_mondiale/API_SI.POV.GINI_DS2_en_csv_v2_2357065.csv")
gini_data_all.head(3)

	Country Name	Country Code	Indicator Name	Indicator Code	1960	1961	1962	1963	1964	1965	...	2011	2012	2013	2014	2015	2016	2017	2018	2019	2020
0	Aruba	ABW	Gini index (World Bank estimate)	SI.POV.GINI	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
1	Afghanistan	AFG	Gini index (World Bank estimate)	SI.POV.GINI	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
2	Angola	AGO	Gini index (World Bank estimate)	SI.POV.GINI	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	51.3	NaN	NaN

3 rows × 65 columns

# verif format colonnes
gini_data_all.dtypes

Country Name       object
Country Code       object
Indicator Name     object
Indicator Code     object
1960              float64
                   ...   
2016              float64
2017              float64
2018              float64
2019              float64
2020              float64
Length: 65, dtype: object

# on divise les valeurs par 100 pour obtenir un indice de Gini entre 0 et 1
gini_data_all.iloc[:,4:] = gini_data_all.iloc[:,4:]/100
gini_data_all.head(3)

	Country Name	Country Code	Indicator Name	Indicator Code	1960	1961	1962	1963	1964	1965	...	2011	2012	2013	2014	2015	2016	2017	2018	2019	2020
0	Aruba	ABW	Gini index (World Bank estimate)	SI.POV.GINI	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
1	Afghanistan	AFG	Gini index (World Bank estimate)	SI.POV.GINI	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
2	Angola	AGO	Gini index (World Bank estimate)	SI.POV.GINI	NaN	NaN	NaN	NaN	NaN	NaN	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	0.513	NaN	NaN

3 rows × 65 columns

# verif que chaque pays n'apparait que une fois
gini_data_all['Country Code'].nunique()
gini_data_all.shape

264

(264, 65)

# On limite les données aux seules années présentes dans le dataset de revenus
annees_revenus=sorted(income_data.year_survey.unique())
annees_revenus

[2004, 2006, 2007, 2008, 2009, 2010, 2011]

annees_gini_selected=[]
for x in annees_revenus :
    annees_gini_selected.append(str(x))

col_sel = ['Country Name','Country Code']
col_sel.extend(annees_gini_selected)
gini_data_sel=gini_data_all[col_sel]
gini_data_sel.head(3)

	Country Name	Country Code	2004	2006	2007	2008	2009	2010	2011
0	Aruba	ABW	NaN	NaN	NaN	NaN	NaN	NaN	NaN
1	Afghanistan	AFG	NaN	NaN	NaN	NaN	NaN	NaN	NaN
2	Angola	AGO	NaN	NaN	NaN	0.427	NaN	NaN	NaN

# On limite les données aux seuls pays présents dans le dataset de revenus

# on récupère la liste des pays du df data (df des revenus)
pays_rev_temp = income_data[['country']].drop_duplicates()
pays_rev_temp.shape

(116, 1)

# on merge les 2 df (on=code_pays) en ne gardant que les pays présents dans le df data
gini_data = pd.merge(gini_data_sel, pays_rev_temp, left_on="Country Code", right_on="country", how="inner")
gini_data.sample(2)

	Country Name	Country Code	2004	2006	2007	2008	2009	2010	2011	country
99	Eswatini	SWZ	NaN	NaN	NaN	NaN	0.515	NaN	NaN	SWZ
22	Costa Rica	CRI	0.483	0.494	0.493	0.486	0.506	0.482	0.487	CRI

# on supprime 'code_pays' en double et on renomme les colonnes
gini_data = gini_data.drop(columns='country')
gini_data.columns=['pays', 'code_pays', '2004', '2006', '2007', '2008', '2009', '2010', '2011']
gini_data.sample(1)
gini_data.shape

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011
20	Congo, Dem. Rep.	COD	0.422	NaN	NaN	NaN	NaN	NaN	NaN

(115, 9)

# On met le nom des pays en français
corr = code_corr_pays[['alpha3', 'nom_pays_fr']]
corr.columns=['code_pays', 'pays']
gini_data = gini_data.drop(columns='pays')
gini_data = pd.merge(gini_data, corr)
gini_data = gini_data.reindex(columns=["code_pays", "pays", "2004", "2006", "2007", "2008", "2009", "2010", "2011"])
gini_data.head(3)
gini_data.shape

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011
0	ALB	Albanie	NaN	NaN	NaN	0.300	NaN	NaN	NaN
1	ARG	Argentine	0.484	0.463	0.462	0.449	0.437	0.436	0.426
2	ARM	Arménie	0.375	0.297	0.312	0.292	0.280	0.300	0.294

(115, 9)

gini_data.shape
income_data.shape

(115, 9)

(11600, 5)

On constate qu'il y a un pays de moins dans 'gini_data' que dans 'income_data'
-> il y a donc un pays présent dans le df des revenus qui n'apparait pas dans celui des coef. de Gini

pays_gini_manquant = set(list(income_data.country)) - set(list(gini_data.code_pays))
pays_gini_manquant

{'TWN'}

code_corr_pays.loc[code_corr_pays['alpha3'] == 'TWN', 'nom_pays_fr']

44    Taïwan
Name: nom_pays_fr, dtype: object

Le pays correspondant est la province de Taïwan
Si cette province est manquante dans le dataset des indices de Gini, c'est peut-être parce que les provinces sont comptabilisées dans la Chine

On regarde le code_pays ISO3 de la Chine

code_corr_pays.loc[code_corr_pays['nom_pays_fr'] == 'Chine', ['nom_pays_fr', 'alpha3']]

	nom_pays_fr	alpha3
43	Chine	CHN

On teste ce code dans le dataset des coef. de Gini

gini_data[gini_data["code_pays"] == "CHN"]

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011
17	CHN	Chine	NaN	NaN	NaN	0.43	NaN	0.437	0.424

On extrait les codes des autres provinces pour voir s'ils apparaissent dans le dataset de Gini

code_p_chine=[]
for z in code_corr_pays.nom_pays_fr:
    if 'Macao' in z or 'Hong-Kong' in z:
        code = code_corr_pays[code_corr_pays['nom_pays_fr'] == z]['alpha3'].values[0]
        code_p_chine.append(code)
code_p_chine

['HKG', 'MAC']

l_chine = ["HKG", "MAC", "CHN", "TWN"]

On verifie la présence de ces code_pays dans le df Gini et dans le df Income

gini_data[gini_data['code_pays'].isin(l_chine)]
income_data[income_data["country"].isin(l_chine)].drop_duplicates("country")

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011
17	CHN	Chine	NaN	NaN	NaN	0.43	NaN	0.437	0.424

	country	year_survey	quantile	income	gdpppp
1700	CHN	2007	1	16.719418	5712.0
10500	TWN	2008	1	3477.180000	25342.0

La Chine est donc référencée comme un seul pays

On supprime donc Taiwan du dataset des revenus et des coef. Gini

income_data.shape
income_data=income_data[income_data['country'] != 'TWN']
income_data.shape

(11600, 5)

(11500, 5)

Haut de page    

3. Population

2 éléments à prendre en compte pour les différentes années:

• la pop mondiale
• les pop nationales

On va utiliser les données de la FAO (on ajoutera aussi le nom des pays en français)

# import des données
pop_data=pd.read_csv("data/inputs/pop_fao.csv")
pop_data.head(3)

	Code Domaine	Domaine	Code zone	Zone	Code Élément	Élément	Code Produit	Produit	Code année	Année	Unité	Valeur	Symbole	Description du Symbole	Note
0	OA	Séries temporelles annuelles	AFG	Afghanistan	511	Population totale	3010	Population-Estimations	2004	2004	1000 personnes	24726.684	X	Sources internationales sûres	NaN
1	OA	Séries temporelles annuelles	AFG	Afghanistan	511	Population totale	3010	Population-Estimations	2005	2005	1000 personnes	25654.277	X	Sources internationales sûres	NaN
2	OA	Séries temporelles annuelles	AFG	Afghanistan	511	Population totale	3010	Population-Estimations	2006	2006	1000 personnes	26433.049	X	Sources internationales sûres	NaN

# on garde les colonnes qui nous intéressent
pop_data = pop_data[['Code zone', 'Zone', 'Code année', 'Valeur']]

# on renomme les colonnes
pop_data.columns = ['code_pays', 'pays', 'annee', 'pop_en_M']
pop_data.sample(2)

	code_pays	pays	annee	pop_en_M
3420	VUT	Vanuatu	2004	204.127
361	BEN	Bénin	2005	7982.225

# pivot_table pour avoir les années en colonnes
pop_data = pop_data.pivot_table(index=['pays', 'code_pays'], columns=['annee'], values='pop_en_M')
pop_data.sample(3)

	annee	2004	2005	2006	2007	2008	2009	2010	2011	2012	2013	2014	2015	2016	2017	2018
pays	code_pays
Îles Salomon	SLB	458.539	469.918	481.078	492.132	503.36	515.181	527.861	541.521	556.063	571.336	587.079	603.118	619.438	636.039	652.857
République démocratique populaire lao	LAO	5662.208	5751.676	5846.074	5944.948	6046.62	6148.623	6249.165	6347.567	6444.530	6541.304	6639.756	6741.164	6845.846	6953.035	7061.507
Monténégro	MNE	NaN	NaN	617.860	619.555	621.32	622.939	624.275	625.270	625.925	626.345	626.645	626.956	627.264	627.563	627.809

pop_data=pop_data.reset_index()
col_n=[]
for col in pop_data.columns:
    col_n.append(str(col))
pop_data.columns=col_n
pop_data.sample(2)

	pays	code_pays	2004	2005	2006	2007	2008	2009	2010	2011	2012	2013	2014	2015	2016	2017	2018
16	Azerbaïdjan	AZE	8448.946	8538.605	8630.146	8724.243	8821.873	8924.388	9032.461	9146.275	9264.692	9385.468	9505.622	9622.745	9736.043	9845.320	9949.537
42	Chine - RAS de Hong-Kong	HKG	6744.566	6769.574	6802.080	6840.015	6881.863	6924.642	6966.331	7006.590	7046.848	7088.778	7134.670	7185.996	7243.542	7306.322	7371.730

# on limite les données aux années présentes dans le dataset revenus
pop_data = pop_data[['pays', 'code_pays', '2004', '2006', '2007', '2008', '2009', '2010', '2011']]
pop_data

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011
0	Afghanistan	AFG	24726.684	26433.049	27100.536	27722.276	28394.813	29185.507	30117.413
1	Afrique du Sud	ZAF	47291.610	48489.459	49119.759	49779.471	50477.011	51216.964	52003.755
2	Albanie	ALB	3104.892	3063.021	3033.998	3002.678	2973.048	2948.023	2928.592
3	Algérie	DZA	32692.163	33641.002	34166.972	34730.608	35333.881	35977.455	36661.445
4	Allemagne	DEU	81646.474	81472.226	81277.830	81065.752	80899.961	80827.002	80855.632
...	...	...	...	...	...	...	...	...	...
235	Îles Salomon	SLB	458.539	481.078	492.132	503.360	515.181	527.861	541.521
236	Îles Turques-et-Caïques	TCA	26.700	29.391	30.385	31.202	31.934	32.660	33.377
237	Îles Vierges américaines	VIR	108.092	107.462	107.115	106.756	106.412	106.087	105.793
238	Îles Vierges britanniques	VGB	22.334	24.023	25.047	26.097	27.039	27.794	28.319
239	Îles Wallis-et-Futuna	WLF	15.093	14.609	14.132	13.578	13.070	12.689	12.462

240 rows × 9 columns

# On distingue la population mondiale des populations nationales
pop_mondiale = pop_data[pop_data['2011'] == pop_data['2011'].max()]
pop_nat = pop_data[pop_data['code_pays'] != 'X01']

pop_mondiale

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011
124	Monde	X01	6461159.389	6623517.833	6705946.61	6789088.686	6872767.093	6956823.603	7041194.301

pays_rev_temp = income_data[['country']].drop_duplicates()
pays_rev_temp.shape

(115, 1)

# On limite les données de pop_nat aux pays présents dans dataset revenus
pop_nat_sel = pd.merge(pop_nat, pays_rev_temp, left_on="code_pays", right_on="country", how="inner")
pop_nat_sel.shape

(114, 10)

Il manque un pays dans le df pop

set(list(pays_rev_temp['country']))-set(list(pop_nat_sel['code_pays']))

{'XKX'}

Il s'agit à nouveau du Kosovo.
Après des recherches, il s'avère que ce territoire est considéré comme indépendant par certaines institutions, ou comme faisant partie de la Serbie pour d'autres.

La FAO comptabilise la population du Kosovo avec celle de la Serbie :
-> on va régulariser en 2 temps :

• ajout de la pop du Kosovo à partir des data de la Bq Mondiale
• On ajuste la pop de la Serbie (nos données pop proviennent de la FAO) en la diminuant de la pop du Kosovo
  

• Remarque : avant 2016 ce n'est pas la Serbie mais la "Serbie-et-Monténégro"
  --> pour simplifier, on va inclure les données de 2014 de la "Serbie-et-Monténégro" dans les données de la Serbie et du Monténégro

pop_kos = pd.read_csv("data/inputs/pop_kos.csv", delimiter=";")
pop_kos

	sérieName	pays	code_pays	2004	2006	2007	2008	2009	2010	2011
0	Population	Monténégro	MNE	613353	615025	615875	616969	618294	619428	620079
1	Population	Serbie	SRB	7463157	7411569	7381579	7350222	7320807	7291436	7234099
2	Population	Kosovo	XKX	1704622	1719536	1733404	1747383	1761474	1775680	1791000

# Ajout de la pop du Kosovo
years=sorted(income_data.year_survey.unique())
pop_kosovo = {}
for y in years:
    pop_kosovo[str(y)] = (pop_kos.loc[pop_kos['code_pays'] == 'XKX', str(y)].values[0])/1000
pop_new_temp={'pays': 'Kosovo', 'code_pays': 'XKX', 'country': 'XKX'}
pop_new = {**pop_new_temp, **pop_kosovo}

pop_nat_sel = pop_nat_sel.append(pop_new, ignore_index=True)
pop_nat_sel[pop_nat_sel['code_pays'] == 'XKX']

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011	country
114	Kosovo	XKX	1704.622	1719.536	1733.404	1747.383	1761.474	1775.68	1791.0	XKX

# Ajustement de la pop de la serbie et du Monténégro pour 2014 (données du pays 'Serbie-et-Monténégro')
p_serbie = pop_kos.loc[pop_kos['code_pays'] == 'SRB', '2004']
p_mont = pop_kos.loc[pop_kos['code_pays'] == 'MNE', '2004']
pop_nat_sel.loc[pop_nat_sel['code_pays'] == 'SRB', '2004'] = p_serbie.values/1000
pop_nat_sel.loc[pop_nat_sel['code_pays'] == 'MNE', '2004'] = p_mont.values/1000

# # Ajustement de la pop de la serbie pour les autres années
for y in years[1:]:
        pop_nat_sel.loc[pop_nat_sel['code_pays'] == 'SRB', str(y)] = pop_nat_sel.loc[pop_nat_sel['code_pays'] == 'SRB', str(y)] - (pop_kosovo[str(y)]/1000)
pop_nat_sel[pop_nat_sel['code_pays'] == 'SRB']
pop_nat_sel[pop_nat_sel['code_pays'] == 'MNE']

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011	country
95	Serbie	SRB	7463.157	9144.194464	9099.451596	9058.355617	9021.595526	8989.47832	8961.978	SRB

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011	country
68	Monténégro	MNE	613.353	617.86	619.555	621.32	622.939	624.275	625.27	MNE

# on verifie la présence de valeurs nulles
pop_nat_sel.isna().sum()

pays         0
code_pays    0
2004         1
2006         1
2007         1
2008         1
2009         1
2010         1
2011         1
country      0
dtype: int64

#for year in ['2004', '2006', '2007', '2008', '2009', '2010', '2011']:
pop_nat_sel[pop_nat_sel['2004'].isna()]

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011	country
98	Soudan	SDN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	SDN

• Le Soudan
  • on va récupérer les données démographiques du pays "Soudan (ex)" qui a pour code_pays alpha3 '206' dans la nomenclature de la FAO
  • on remplace les NaN par ces valeurs

soudan_new=[]
for year in ['2004', '2006', '2007', '2008', '2009', '2010', '2011']:
        soudan_new.append(pop_data.loc[pop_data['code_pays'] == '206', year].values[0])

for i,year in enumerate(['2004', '2006', '2007', '2008', '2009', '2010', '2011']):
    pop_nat_sel.loc[pop_nat_sel['code_pays'] == 'SDN', year] = soudan_new[i]

pop_nat_sel[pop_nat_sel['code_pays'] == 'SDN']
pop_nat_sel.shape

	pays	code_pays	2004	2006	2007	2008	2009	2010	2011	country
98	Soudan	SDN	37427.544	39569.229	40675.76	41797.776	42926.047	44053.377	45180.38	SDN

(115, 10)

Haut de page    

Mission 1 : Résumé des données initiales

Périmètre temporel et spatial de l'analyse

y_num=sorted(income_data.year_survey.unique())
y_str = [str(x) for x in y_num]
txt=""
for i,y in enumerate(y_str):
    txt = txt + (y+', ' if i<len(y_str)-1 else y+'.')
print('Les données concernent les années suivantes : ' + txt)

Les données concernent les années suivantes : 2004, 2006, 2007, 2008, 2009, 2010, 2011.

# 100 valeurs par pays
nb_total_pays = income_data.shape[0]/100
print(f"{int(nb_total_pays)} pays représentés, répartis de la façon suivante :")

l_nb_pays_income=[]
for y in y_num:
    df = income_data[income_data['year_survey'] == y]
    # 100 valeurs par pays
    nb_pays = int(df.shape[0]/100)
    l_nb_pays_income.append(nb_pays)
    print(f" - Année {y} : {nb_pays} pays")

115 pays représentés, répartis de la façon suivante :
 - Année 2004 : 1 pays
 - Année 2006 : 5 pays
 - Année 2007 : 15 pays
 - Année 2008 : 75 pays
 - Année 2009 : 12 pays
 - Année 2010 : 6 pays
 - Année 2011 : 1 pays

plt.figure(figsize=(10,5))
plt.xticks(y_num)
plt.xlabel('Années')
plt.ylabel('Nb de pays')
plt.title('Nombre de pays par année')
plt.bar(x=y_num, height=l_nb_pays_income, color='teal', zorder=3)
plt.grid(True, linestyle='--', alpha=0.3, zorder=2)
plt.tight_layout()
plt.savefig('data/exports/img_charts/01.nombre_pays_dataset_par_annee.png', dpi = 200)
plt.show();

Haut de page    

Données concernant l'indice de Gini

print("L'indice de Gini est disponible pour différentes années.")
print("La répartition est la suivante :")
l_nb_pays_gini=[]
for y in y_str:
    nb_pays_gini = gini_data.shape[0] - gini_data[y].isna().sum()
    l_nb_pays_gini.append(nb_pays_gini)
    print(f" - Année {y} : {nb_pays_gini} pays")

L'indice de Gini est disponible pour différentes années.
La répartition est la suivante :
 - Année 2004 : 65 pays
 - Année 2006 : 68 pays
 - Année 2007 : 67 pays
 - Année 2008 : 68 pays
 - Année 2009 : 70 pays
 - Année 2010 : 71 pays
 - Année 2011 : 66 pays

On regarde si tous les pays ont au moins une valeur

# nb d'années représentées
nb_annees = len(y_str)
# nb de NaN par lignes (donc nb d'année manquante par pays)
nb_nan_gini_pays=gini_data.isna().sum(axis=1)
# verif si nb de NaN par pays = nb d'années représentées
pays_aucun_gini = nb_nan_gini_pays[nb_nan_gini_pays.values == nb_annees]
nb_pays_aucun_gini = pays_aucun_gini.shape[0]
if nb_pays_aucun_gini>0:       
    print(f"{nb_pays_aucun_gini} pays n'"+("a" if nb_pays_aucun_gini == 1 else "ont")+" aucune valeur d'indice de Gini")
else:
    print("Tous les pays ont au moins une valeur de Gini")

7 pays n'ont aucune valeur d'indice de Gini

On crée un df de ces 7 pays (nous rajouterons l'indice de Gini pour une année juste après)

df_pays_sans_gini = gini_data[gini_data.index.isin(pays_aucun_gini.index)]
df_pays_sans_gini

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011
37	GHA	Ghana	NaN	NaN	NaN	NaN	NaN	NaN	NaN
55	KEN	Kenya	NaN	NaN	NaN	NaN	NaN	NaN	NaN
57	KHM	Cambodge	NaN	NaN	NaN	NaN	NaN	NaN	NaN
71	MNE	Monténégro	NaN	NaN	NaN	NaN	NaN	NaN	NaN
95	SRB	Serbie	NaN	NaN	NaN	NaN	NaN	NaN	NaN
100	SYR	République Arabe Syrienne	NaN	NaN	NaN	NaN	NaN	NaN	NaN
113	YEM	Yémen	NaN	NaN	NaN	NaN	NaN	NaN	NaN

Haut de page    

Données démographiques

# liste de l'effectif pop mondiale par année
cols_annee = [str(x) for x in annees_revenus]
l_pop_mondiale = pop_mondiale[cols_annee]
l_pop_mondiale=list(l_pop_mondiale.values[0]*1000)
l_pop_mondiale=[int(x) for x in l_pop_mondiale]

# liste de l'effectif pop analysée par année 
l_pop_analyse = [int(1000*x) for x in pop_nat_sel[cols_annee].sum()]

# df pop par année avec part de la pop étudiée / pop mondiale
pop_data=pd.DataFrame(index=cols_annee, 
                      columns=['pop_mondiale', 'pop_analyse'],
                     data={'pop_mondiale':l_pop_mondiale, 'pop_analyse':l_pop_analyse})
pop_data['part_pop_analyse'] = round(100*(pop_data['pop_analyse'] / pop_data['pop_mondiale']),2)
pop_data

	pop_mondiale	pop_analyse	part_pop_analyse
2004	6461159389	5965985908	92.34
2006	6623517833	6108503125	92.22
2007	6705946610	6179609328	92.15
2008	6789088686	6251081605	92.08
2009	6872767093	6322742818	92.00
2010	6956823603	6394448759	91.92
2011	7041194301	6466129243	91.83

# calcul de la part de la pop moindiale représentée pour 2008
part_pop_analyse_2008 = pop_data.loc['2008', 'part_pop_analyse']

# calcul de la part de pays étudiés / nb pays total
nb_total_pays = code_corr_pays.shape[0]
nb_pays_analyse = pop_nat_sel.shape[0]
part_pays_analyse = round(100*nb_pays_analyse / nb_total_pays,2)

print(f" Ainsi, au total, {nb_pays_analyse} pays sont analysés, ce qui représente, en prenant les données démographiques de 2008 :")
print(f"   - {part_pays_analyse}% du nombre mondial de pays,")
print(f"   - {part_pop_analyse_2008}% de la population mondiale.")

 Ainsi, au total, 115 pays sont analysés, ce qui représente, en prenant les données démographiques de 2008 :
   - 47.13% du nombre mondial de pays,
   - 92.08% de la population mondiale.

Haut de page    

Type de quantiles utilisés

Les revenus sont distribués par centiles de la population
Exemple avec le quantile 1 pour la France

income_data[income_data['country'] == 'FRA'].head(1)

	country	year_survey	quantile	income	gdpppp
3400	FRA	2008	1	2958.304	30357.0

On peut lire cette ligne de la façon suivante : 1% de la population français dispose d'un revenu annuel moyen de 2958.3€

• Double intérêt à distribuer ainsi nos données :
  • permettre de classer facilement les individus
  • permettre des comparaisons entre plusieurs distributions (ici entre différents pays)

Haut de page    

Unité $PPP

Il s'agit d'un taux de conversion fictif qui permet la comparaison des pouvoirs d’achat des différentes monnaies.
Cette unité est fixée en définissant un panier de consommation "normalisé" c'est-à-dire identique dans tous les pays

Exemple : si ce panier de biens coûte 100 euros en France et 120 dollars aux Etats-Unis, la PPA sera de 1 euro = 1,20 dollar
(alors que le taux de change peut être de 1 euro = 1,4 dollar).

C'est donc une unité qui rend possible les comparaisons internationales en supprimant l'effet du taux de change

Haut de page    

Mission 2 : Diversité des revenus et indices de Gini

• On va calculer les indices de Gini avec les données du df income_data et réaliser une carte mondiale pour représenter la répartition selon les pays.

• Nous réaliserons 2 cartes :
  • une carte qui représentera la répartition mondiale en 2008 pour les 75 pays dont nous avons les données pour cette année
  • une carte qui représentera la répartition des 115 pays présents dans le df income_data mais avec des indices de Gini d'années différentes selon les pays

Calcul des indices de Gini

# fonction calcul de l'indice de Gini
def gini(arr):
    count = arr.size
    coefficient = 2 / count
    indexes = np.arange(1, count + 1)
    weighted_sum = (indexes * arr).sum()
    total = arr.sum()
    constant = (count + 1) / count
    return coefficient * weighted_sum / total - constant

# création d'un df qui contiendra les valeurs de gini calculées
pays = pop_nat_sel[['code_pays', 'pays']]
col_gini=['gini_2004', 'gini_2006', 'gini_2007', 'gini_2008', 'gini_2009', 'gini_2010', 'gini_2011']
d={'code_pays': list(pays.code_pays)}
df_gini_cal=pd.DataFrame(data=d, index=pop_nat_sel.pays)
for col in col_gini:
    df_gini_cal[col] = np.nan
df_gini_cal.head(1)

	code_pays	gini_2004	gini_2006	gini_2007	gini_2008	gini_2009	gini_2010	gini_2011
pays
Afrique du Sud	ZAF	NaN	NaN	NaN	NaN	NaN	NaN	NaN

# On remplit le df_gini_cal en fonction des données de income_data
liste_pays=income_data['country'].tolist()
gini_dic = {}
for pays in liste_pays:
    df = income_data[income_data['country'] == pays]
    years = df.year_survey.unique()
    for y in years:
        key=str(pays)+'_'+str(y)
        dfy = df[df['year_survey'] == y]
        inc = dfy.income.values
        inc = np.sort(inc)
        gini_value = gini(inc)
        gini_value = gini_value
        gini_dic[key] = gini_value
        df_gini_cal.loc[df_gini_cal['code_pays'] == pays, 'gini_'+str(y)] = gini_value

Haut de page    

Cartes mondiales des indices de gini

import locale
locale.setlocale(locale.LC_ALL, 'fr_FR.utf8')

# préparation du dataframe pour la carte 2008
df_map = df_gini_cal[['code_pays', 'gini_2008']]
df_map = df_map.reset_index()
df_map = df_map.dropna()
df_income_map = income_data[['country', 'gdpppp']].drop_duplicates()
df_income_map.columns=['code_pays', 'gdp']
df_map = pd.merge(df_map, df_income_map, how='inner')
df_pop_temp = pop_nat_sel[['code_pays', '2008']]
df_pop_temp.columns = ['code_pays', 'pop_2008']
df_map = pd.merge(df_map, df_pop_temp, how='inner')
#df_map['gdp']=df_map['gdp'].apply(lambda x: locale.currency(int(x), grouping=True))
df_map['gdp']=df_map['gdp'].apply(lambda x: str('{:n}'.format(int(x))+' $'))
df_map['pop_2008']=df_map['pop_2008'].apply(lambda x: str('{:n}'.format(int(1000*x))))
df_map.sample(2)

'fr_FR.utf8'

	pays	code_pays	gini_2008	gdp	pop_2008
19	Danemark	DNK	0.259871	34 130 $	5 497 729
15	Colombie	COL	0.569271	8 185 $	44 254 975

######################################################################################
##   Carte 1 : Seulement avec les données de 2008
######################################################################################

import plotly.express as px
import plotly.graph_objects as go

df_map['text'] = '<br>' + \
    df_map['pays'] + '<br>' + \
    'PIB/hab : ' + df_map['gdp'] + '<br>' + \
    'Pop : ' + df_map['pop_2008']

fig = go.Figure(data=go.Choropleth(locations=df_map["code_pays"],
                    z=df_map["gini_2008"],
                    text=df_map["text"],
                    autocolorscale=False,
                    reversescale=False,
                    marker_line_color='darkgray',
                    marker_line_width=0.5,
                    colorscale=px.colors.sequential.tempo,
                    colorbar_title="Coef. de Gini"))

fig.update_layout(
    title_text='Coefficients de Gini - 2008',
    geo=dict(
        showframe=False),
    autosize=True,
    width=1400,
    height=800,
    margin=dict(
        l=50,
        r=50,
        b=100,
        t=75,
        pad=4
    ),
    paper_bgcolor="white")

fig.write_html("data/exports/img_charts/02.carte_mondiale_gini_2008.html")
fig.write_image("data/exports/img_charts/02.carte_mondiale_gini_2008.png")

# Prépa des données pour la carte avec tous les pays
pays = pop_nat_sel[['code_pays', 'pays']]
d={'code_pays': list(pays.code_pays), 'pays': list(pays.pays)}
df_gini=pd.DataFrame(data=d, index=pop_nat_sel.pays)
df_gini['annee']=""
df_gini['val_gini']=""

for k,v in gini_dic.items():
    cp = k.split('_')[0]
    annee = k.split('_')[1]
    
    df_gini.loc[df_gini['code_pays'] == cp, 'annee'] = annee
    df_gini.loc[df_gini['code_pays'] == cp, 'val_gini'] = v
    
df_income_map = income_data[['country', 'gdpppp']].drop_duplicates()
df_income_map.columns=['code_pays', 'gdp']
df_gini = pd.merge(df_gini, df_income_map)
df_pop_temp = pop_nat_sel[['code_pays', '2008']]
df_pop_temp.columns = ['code_pays', 'pop_2008']
df_gini = pd.merge(df_gini, df_pop_temp)

df_gini['val_gini']=df_gini['val_gini'].apply(lambda x: round(x,4))
df_gini['gdp']=df_gini['gdp'].apply(lambda x: str('{:n}'.format(int(x))+' $'))
df_gini['pop_2008']=df_gini['pop_2008'].apply(lambda x: str('{:n}'.format(int(1000*x))))
df_gini.sample(2)

	code_pays	pays	annee	val_gini	gdp	pop_2008
14	BFA	Burkina Faso	2009	0.3976	1 085 $	14 689 725
90	MDA	République de Moldova	2008	0.3114	2 768 $	4 112 890

######################################################################################
##   Carte 2 : Représentation de tous les pays 
##   (mais années différentes pour coef de Gini)
######################################################################################

df_gini['text'] = '(Année ' + df_gini['annee'] + ')' +'<br><br>' + \
    df_gini['pays'] + '<br>' + \
    'PIB/hab : ' + df_gini['gdp'] + '<br>' + \
    'Pop : ' + df_gini['pop_2008']

fig = go.Figure(data=go.Choropleth(locations=df_gini["code_pays"],
                    z=df_gini["val_gini"], 
                    text=df_gini["text"],
                    autocolorscale=False,
                    reversescale=False,
                    marker_line_color='darkgray',
                    marker_line_width=0.5,
                    colorscale=px.colors.sequential.tempo,
                    colorbar_title="Coef. de Gini"))

fig.update_layout(
    title_text='Coefficients de Gini (2004-2011 selon les pays)',
    geo=dict(
        showframe=False),
    autosize=True,
    width=1400,
    height=800,
    margin=dict(
        l=50,
        r=50,
        b=100,
        t=75,
        pad=4
    ),
    paper_bgcolor="white",)

fig.write_html("data/exports/img_charts/03.carte_mondiale_gini_une_valeur_2004_2011.html")
fig.write_image("data/exports/img_charts/03.carte_mondiale_gini_une_valeur_2004_2011.png")

• On traite les pays qui n'ont aucun indice de Gini

code_pays_sans_gini = df_pays_sans_gini.code_pays.tolist()
for cp in code_pays_sans_gini:
    annee = df_gini.loc[df_gini['code_pays'] == cp, 'annee'].values[0]
    val = df_gini.loc[df_gini['code_pays'] == cp, 'val_gini'].values[0]
    gini_data.loc[gini_data['code_pays'] == cp, str(annee)] = val

# On vérifie que les 7 pays concernés ont désormais un indice de Gini pour une année
gini_data[gini_data.index.isin(pays_aucun_gini.index)]

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011
37	GHA	Ghana	NaN	0.4276	NaN	NaN	NaN	NaN	NaN
55	KEN	Kenya	NaN	NaN	0.2989	NaN	NaN	NaN	NaN
57	KHM	Cambodge	NaN	NaN	NaN	0.3137	NaN	NaN	NaN
71	MNE	Monténégro	NaN	NaN	NaN	0.2906	NaN	NaN	NaN
95	SRB	Serbie	NaN	NaN	NaN	0.2752	NaN	NaN	NaN
100	SYR	République Arabe Syrienne	0.3576	NaN	NaN	NaN	NaN	NaN	NaN
113	YEM	Yémen	NaN	NaN	NaN	0.3742	NaN	NaN	NaN

• On pourrait également se servir des coef que nous avons calculés pour remplacer les autres valeurs manquantes du dataset de la banque mondiale.
  Mais pb : ce n'est pas la même année de référence qui est utilisée pour le calcul du $PPP

• On va donc comparer, quand cela est possible, les données que nous avons calculées avec les valeurs du dataset de la Bq Mondiale

# merge des 2 df : gini calculé et gini bq mondiale
gini_diff = pd.merge(gini_data, df_gini[['code_pays', 'annee', 'val_gini']])

# pour chaque pays, s'il existe les 2 valeurs, on calcule la différence
for pays in gini_diff.code_pays:
    annee_cal = gini_diff.loc[gini_diff['code_pays'] == pays, 'annee'].values[0]
    if gini_diff.loc[gini_diff['code_pays'] == pays, str(annee_cal)].isna().values[0] is not True:
        gini_diff['difference'] = gini_diff['val_gini'] - gini_diff[annee_cal]

# on crée un col avec la valeur absolue de la différence        
gini_diff['difference_abs'] = gini_diff['difference'].apply(lambda x: -x if x<0 else x)
gini_diff.sample(3)
avg_diff = gini_diff['difference_abs'].mean()
max_diff = gini_diff['difference_abs'].max()
print(f"Différence moyenne : {avg_diff:.2f}")
print(f"Différence max : {max_diff:.2f}")

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011	annee	val_gini	difference	difference_abs
76	MYS	Malaisie	NaN	0.448	NaN	0.455	NaN	NaN	0.439	2009	0.4682	0.0132	0.0132
59	LAO	République Démocratique Populaire Lao	NaN	NaN	0.354	NaN	NaN	NaN	NaN	2007	0.3542	NaN	NaN
32	FIN	Finlande	0.279	0.280	0.283	0.278	0.275	0.277	0.276	2008	0.2769	-0.0011	0.0011

Différence moyenne : 0.02
Différence max : 0.08

On constate que les écarts sont importants
-> Nous allons donc utiliser uniquement les valeurs de la Banque Mondiale

Haut de page    

Diversité des pays en terme de distribution des revenus

On définit un df des pays disposant de l'indice de Gini pour toutes les années de l'étude

y_str

['2004', '2006', '2007', '2008', '2009', '2010', '2011']

# nb de NaN par lignes (donc nb d'années manquantes par pays)
nb_nan_gini_pays=gini_data.isna().sum(axis=1)
# selection des pays avec coef de Gini pour toutes les années
pays_gini_complet = nb_nan_gini_pays[nb_nan_gini_pays.values == 0]
# df gini_ok avec pays qui ont toutes les valeurs
df_gini_complet = gini_data[gini_data.index.isin(pays_gini_complet.index)]

df_gini_complet=df_gini_complet.reindex(columns=['code_pays', 'pays', '2004', '2006', '2007', '2008', '2009', '2010', '2011'])
nb_pays_gini_complet = df_gini_complet.shape[0]
print(f"{nb_pays_gini_complet} pays disposent d'un indice de Gini pour toutes les années")

48 pays disposent d'un indice de Gini pour toutes les années

print(df_gini_complet.code_pays.tolist())

['ARG', 'ARM', 'AUT', 'BEL', 'BLR', 'CRI', 'CYP', 'CZE', 'DEU', 'DNK', 'DOM', 'ECU', 'ESP', 'EST', 'FIN', 'FRA', 'GBR', 'GEO', 'GRC', 'HND', 'HUN', 'IDN', 'IRL', 'ISL', 'ITA', 'KAZ', 'KGZ', 'LTU', 'LUX', 'LVA', 'MDA', 'NLD', 'NOR', 'PAN', 'PER', 'POL', 'PRT', 'PRY', 'RUS', 'SLV', 'SVK', 'SVN', 'SWE', 'THA', 'TUR', 'UKR', 'URY', 'USA']

• Choix des pays

  • On limite notre recherche aux 48 pays qui ont un indice de Gini pour toutes les années
  • On va choisir les pays suivants :
    • pays avec l'indice de Gini min et max
    • pays avec PIB/hab min et max
    • pays avec le rapport "1% les plus pauvres / 1% les plus riches" min et max

def nom_pays(code):
    df = code_corr_pays[['alpha3', 'nom_pays_fr']]
    df.columns = ['code_pays', 'pays']
    nom_pays = df.loc[df['code_pays'] == code, 'pays'].values[0]
    return nom_pays

def test_presence_pays(val):
    code = list(val[val.columns[0]])
    for i,c in enumerate(code):
        if c in pays_selected:
            continue
        else:
            pays_selected.append(c)
            break
    return c            

# liste des 48 pays avec les données pour toutes les années (on utilisera l'indice moyen sur l'ensemble des années)
pays_selected=[]

# calcul de l'indice moyen
df_gini_complet['avg_gini'] = df_gini_complet.mean(axis=1)
df_gini_complet['avg_gini'] = df_gini_complet['avg_gini'].apply(lambda x: round(x,1))

# le pays avec l'indice de Gini le plus faible
x1=df_gini_complet.nsmallest(1, 'avg_gini').code_pays.values[0]
pays_selected.append(x1) 
print("gini_avg min : " + nom_pays(x1))

# le pays avec l'indice de Gini le plus élevé
x2=df_gini_complet.nlargest(1, 'avg_gini').code_pays.values[0]
pays_selected.append(x2)
print("gini_avg max : " + nom_pays(x2))

# on limite le df income aux 48 pays
inc_select = income_data[income_data['country'].isin(list(df_gini_complet.code_pays))]

# le pays avec le PIB/hab le plus faible
x3=inc_select[['country', 'income']].nsmallest(10, 'income')
x_3=test_presence_pays(x3)
print("pib/hab min : " + nom_pays(x_3))

# le pays avec le PIB/hab le plus élevé
x4=inc_select[['country', 'income']].nlargest(10, 'income')
x_4=test_presence_pays(x4)
print("pib/hab max : " + nom_pays(x_4))

# calcul du rapport "1% + pauvres / 1% + riches"
inc_temp = inc_select.groupby('country')['income'].agg([min, max])
inc_temp['rapport_pr'] = inc_temp['max']/inc_temp['min']
inc_temp=inc_temp.reset_index()

# le pays avec le rapport d'inégalité le plus faible
x5=inc_temp[['country', 'rapport_pr']].nsmallest(10, 'rapport_pr')
x_5=test_presence_pays(x5)
print("rapport riches-pauvres min : " + nom_pays(x_5))

# le pays avec le rapport d'inégalité le plus élevé
x6=inc_temp[['country', 'rapport_pr']].nlargest(10, 'rapport_pr')
x_6=test_presence_pays(x6)
print("rapport riches-pauvres min : " + nom_pays(x_6))

gini_avg min : Slovénie
gini_avg max : Honduras
pib/hab min : Géorgie
pib/hab max : États-Unis
rapport riches-pauvres min : Ukraine
rapport riches-pauvres min : Paraguay

pays_selected

['SVN', 'HND', 'GEO', 'USA', 'UKR', 'PRY']

#plt.style.use('seaborn-white')
plt.figure(figsize=(8,8))
plt.yscale('log')
df={}
colors=['#24799e', '#ff9f1a', '#d72828', '#8f7a66',  '#5af6dc', '#360eb9', '#cdb60a', '#474a4d']
plt.xlabel("centiles de revenus")
plt.ylabel("log du revenu moyen")
plt.title("Diversité des pays en terme de distribution des revenus", color="darkred", fontsize=14)
for i,pays in enumerate(pays_selected):
    df[pays] = income_data[income_data["country"] == pays]
    pays_name = code_corr_pays.loc[code_corr_pays['alpha3'] == pays, 'nom_pays_fr'].values[0]
    plt.plot(df[pays]['quantile'], df[pays]['income'], color=colors[i], label=pays_name)
plt.legend(loc='upper left', bbox_to_anchor=(0.02, 0.98), fontsize=10, frameon=True, ncol=1, fancybox=True,
        framealpha=1, shadow=True, borderpad=0.5, facecolor="white", edgecolor="black")
plt.grid(True, linestyle='--', alpha=0.3)
plt.tight_layout()
plt.savefig('data/exports/img_charts/04.diversite_pays_distribution_revenus.png', dpi = 200)
plt.show();

Haut de page    

Courbes de Lorenz

pays_name = []
for code in pays_selected:
    pays_name.append(nom_pays(code))
pays_name

['Slovénie', 'Honduras', 'Géorgie', 'États-Unis', 'Ukraine', 'Paraguay']

from fonctions_perso import lorenz_pers 
incomes = []
for cp in pays_selected:
    incomes.append(income_data[income_data["country"] == cp]['income'])
#plt.style.use('seaborn-white')
#jtplot.style(theme='grade3')
lorenz_pers(incomes, 
         title="Courbe de Lorenz", 
         xlabel="Proportion cumulée de la population", 
         ylabel="Proportion cumulée des revenus", 
         nb=6, fs=8, 
         title_lorenz=pays_name, 
         mediatrice=True)
plt.tight_layout() 
plt.savefig('data/exports/img_charts/05.courbes_lorenz_synthetique.png', dpi = 200)
plt.show()

riches_20p={}
plt.figure(figsize=(13, 8))
for i,pays in enumerate(pays_selected):
    inc = income_data[income_data["country"] == pays]['income']
    name_p = nom_pays(pays)
    inc_sort = inc.sort_values()
    n = len(inc_sort)
    lorenz = np.cumsum(inc_sort) / inc_sort.sum()
    lorenz = np.append([0], lorenz)
    v_moins=round(100*lorenz[20],2)
    v_plus=round(100*(1-lorenz[80]),2)
    riches_20p[i]={'pays': name_p, 'val_moins': v_moins, 'val_plus': v_plus}
    sub_plot = int("23"+str(i+1))
    lorenz_pers(inc, 
         title="Courbe de Lorenz", 
         xlabel="Proportion cumulée de la population", 
         ylabel="Proportion cumulée des revenus", 
         nb=1, fs=None, 
         sub_conf=sub_plot,
         sub_nb=i,
         title_lorenz=name_p, 
         mediatrice=None,
         vert=True)
plt.tight_layout() 
plt.savefig('data/exports/img_charts/06.courbes_lorenz_par_pays_selected.png', dpi = 200)
plt.show();

for i in range(len(riches_20p)):
    pays=riches_20p[i]['pays']
    vm=riches_20p[i]['val_moins']
    vp=riches_20p[i]['val_plus']
    print(f"{pays} : les 20% les plus pauvres perçoivent {vm}% des revenus, les 20% les plus riches {vp}%")

Slovénie : les 20% les plus pauvres perçoivent 10.42% des revenus, les 20% les plus riches 33.59%
Honduras : les 20% les plus pauvres perçoivent 2.07% des revenus, les 20% les plus riches 63.35%
Géorgie : les 20% les plus pauvres perçoivent 5.62% des revenus, les 20% les plus riches 45.01%
États-Unis : les 20% les plus pauvres perçoivent 4.43% des revenus, les 20% les plus riches 47.98%
Ukraine : les 20% les plus pauvres perçoivent 9.92% des revenus, les 20% les plus riches 35.49%
Paraguay : les 20% les plus pauvres perçoivent 3.52% des revenus, les 20% les plus riches 57.03%

Haut de page    

Evolution de l'indice de Gini

Sur les années de l'analyse (2004-2011)

df_gini_complet.sample(1)

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011	avg_gini
97	SVN	Slovénie	0.248	0.244	0.244	0.237	0.248	0.249	0.249	0.2

plt.style.use('seaborn-notebook')
plt.figure(figsize=(12, 6))
plt.ylim(0.15,0.65)
plt.xlim(2003.5,2011.5)
for i,pays in enumerate(pays_selected):
    gini_val=[]
    labels = y_num
    df_evol_gini = df_gini_complet[df_gini_complet['code_pays'] == pays]
    df_evol_gini = df_evol_gini[y_str]
    for y in y_str:
        gini_val.append(df_evol_gini[y].values[0])
    plt.plot(labels, gini_val, 'o-', label=nom_pays(pays))
    
plt.ylabel("Indice de Gini", color="gray")
plt.title("Evolution de l'indice de Gini", color="darkred", fontsize=16, y=1.03)
plt.legend(loc='upper right', bbox_to_anchor=(1.15, 0.98), fontsize=10, frameon=True, ncol=1, fancybox=True,
        framealpha=1, shadow=True, borderpad=0.5, facecolor="white", edgecolor="black")
plt.grid(True, linestyle='--', alpha=0.3)
plt.tight_layout()
plt.savefig('data/exports/img_charts/07.evolution_gini_pays_selected_2004_2011.png', dpi = 200)
plt.show();

Sur toutes les années disponibles

gini_data_all_sel = gini_data_all.loc[gini_data_all['Country Code'].isin(pays_selected),:]
gini_all = gini_data_all_sel.drop(columns=['Country Name', 'Indicator Name', 'Indicator Code'])
gini_all.shape

(6, 62)

gini_all=gini_all.rename({'Country Code': 'code_pays'}, axis=1)
for col in gini_all.columns[1:]:
    if gini_all[col].sum() == 0.:
        gini_all=gini_all.drop(columns=col)
gini_all.shape

(6, 35)

plt.style.use('seaborn-notebook')
plt.figure(figsize=(12, 6))
plt.ylim(0.15,0.65)
y_all_str=gini_all.columns[1:]
y_all_num=[int(x) for x in y_all_str]

x_min=float(y_all_num[0]) - 0.5
x_max=float(y_all_num[-1]) + 0.5
#plt.xlim(x_min, x_max)
plt.xlim(1970, 2020)
for i,pays in enumerate(pays_selected):
    gini_all_val=[]
    df_evol_gini_all = gini_all[gini_all['code_pays'] == pays]
    df_evol_gini_all = df_evol_gini_all[y_all_str]
    df_evol_gini_all = df_evol_gini_all.dropna(axis=1)
    labels = [int(x) for x in df_evol_gini_all.columns]
    for y in df_evol_gini_all.columns:
        gini_all_val.append(df_evol_gini_all[y].values[0])
    plt.plot(labels, gini_all_val, 'o-', label=nom_pays(pays))
    plt.grid(linestyle='--', alpha=0.3)
plt.ylabel("Indice de Gini", color="gray")
plt.title("Evolution de l'indice de Gini", color="darkred", fontsize=16, y=1.03)
plt.legend(loc='upper right', bbox_to_anchor=(1.15, 0.98), fontsize=10, frameon=True, ncol=1, fancybox=True,
        framealpha=1, shadow=True, borderpad=0.5, facecolor="white", edgecolor="black")
plt.grid(True, linestyle='--', alpha=0.3)
plt.tight_layout()
plt.savefig('data/exports/img_charts/08.evolution_gini_pays_selected_depuis_1970.png', dpi = 200)
plt.show();

Haut de page    

Classement des pays par indice de Gini

• Pour pouvoir prendre en compte les 115 pays du dataset, on va utiliser l'indice de Gini moyen pour chaque pays

gini_data['gini_avg']=gini_data.mean(axis=1)
gini_data.sample(1)

	code_pays	pays	2004	2006	2007	2008	2009	2010	2011	gini_avg
86	PHL	Philippines	NaN	0.472	NaN	NaN	0.463	NaN	NaN	0.4675

# on vérifie l'abscence de valeurs nulles
gini_data.gini_avg.isna().sum()

0

# on trie le df gini_data par la colonne gini_avg
gini_comp = gini_data.sort_values(by='gini_avg')
# on fait un reset_index() pour mettre à jour l'index (permettra d(avoir le rang de chaque pays)
gini_comp = gini_comp.reset_index()

# calcul de la moyenne mondiale
gini_avg_monde = gini_comp['gini_avg'].mean()
gini_avg_monde = round(gini_avg_monde,2)

# les 5 pays avec le gini le plus faible
pays_gini_faible = gini_comp.nsmallest(5, 'gini_avg').pays
pays_gini_faible = list(pays_gini_faible)
# les 5 pays avec le gini le plus élevé
pays_gini_eleve = gini_comp.nlargest(5, 'gini_avg').pays
pays_gini_eleve = list(pays_gini_eleve)

# position de la France
val_gini_fr = gini_comp.loc[gini_comp['code_pays'] == 'FRA', 'gini_avg'].values[0]
val_gini_fr = round(val_gini_fr, 2)
pos_fr = (gini_comp[gini_comp['code_pays'] == 'FRA'].index.values[0]) + 1 

str_faibles = ", ".join(pays_gini_faible)
str_eleves = ", ".join(pays_gini_eleve)


display(HTML('<div class="alert alert-block alert-info" style="width:90%;margin:20px,auto,10px,10px;border-color:gray;">'+
'<span style="font-weight:800;">Enseignements du classement des pays par l\'indice de Gini :</span>'+
'<ul>'+
'<li>L\'indice de Gini mondial moyen est de '+str(gini_avg_monde) +'</li>'+
'<li>Les 5 pays les plus égalitaires (donc avec l\'indice de Gini le plus faible) sont : '+str_faibles +'</li>'+
'<li>Les 5 pays les plus inégalitaires (donc avec l\'indice de Gini le plus élevé) sont : '+str_eleves +'</li>'+
'<li>La france se classe en '+str(int(pos_fr)) +'ème position, avec un indice Gini moyen égal à '+str(val_gini_fr)+'</li>'+
'</ul></div>'))

Enseignements du classement des pays par l'indice de Gini :

• L'indice de Gini mondial moyen est de 0.38
• Les 5 pays les plus égalitaires (donc avec l'indice de Gini le plus faible) sont : Slovénie, Danemark, Slovaquie, République Tchèque, Azerbaïdjan
• Les 5 pays les plus inégalitaires (donc avec l'indice de Gini le plus élevé) sont : Afrique du Sud, République Centrafricaine, Honduras, Guatemala, Brésil
• La france se classe en 35ème position, avec un indice Gini moyen égal à 0.32

Haut de page    

Carte mondiale des indices de Gini (valeur moyenne)

On va réaliser une dernière carte en prenant la valeur moyenne

######################################################################################
##   Carte 3 : Représentation de tous les pays 
##   (indice de Gini moyen - période 2004 - 2011)
######################################################################################

df_gini_avg_temp = gini_data.reindex(columns=['code_pays', 'pays', '2004', '2006', '2007', '2008', '2009', '2010', '2011', 'gini_avg'])
df_gini_avg = df_gini_avg_temp[['code_pays', 'pays', 'gini_avg']]

df_gini_avg['text'] = '<br>' + \
    df_gini_avg['pays'] 

fig = go.Figure(data=go.Choropleth(locations=df_gini_avg["code_pays"],
                    z=df_gini_avg["gini_avg"], 
                    text=df_gini_avg["text"],
                    autocolorscale=False,
                    reversescale=False,
                    marker_line_color='darkgray',
                    marker_line_width=0.5,
                    colorscale=px.colors.sequential.tempo,
                    colorbar_title="Coef. de Gini"))

fig.update_layout(
    title_text='Coefficients de Gini moyen (2004-2011)',
    geo=dict(
        showframe=False),
    autosize=True,
    width=1400,
    height=800,
    margin=dict(
        l=50,
        r=50,
        b=100,
        t=75,
        pad=4
    ),
    paper_bgcolor="white",)

fig.write_html("data/exports/img_charts/09.carte_mondiale_gini_moyen_2004_2011.html")
fig.write_image("data/exports/img_charts/09.carte_mondiale_gini_moyen_2004_2011.png")

Export des données

# preparation des données à exporter
income_data.columns = ['code_pays', 'annee', 'centile', 'income', 'gdp']
gini_data = gini_data.reindex(columns=['code_pays', 'pays', '2004', '2006', '2007', '2008', '2009', '2010', '2011', 'gini_avg'])
pop_nat_sel = pop_nat_sel.drop(columns='country')
pop_nat_sel = pop_nat_sel.reindex(columns=['code_pays', 'pays', '2004', '2006', '2007', '2008', '2009', '2010', '2011'])
df_gini_calcule = gini_diff[['code_pays', 'annee', 'val_gini']]

# exportation des données
income_data.to_csv("data/exports/income_data.csv", header=True, index=False)
gini_data.to_csv("data/exports/gini_data.csv", header=True, index=False)
pop_data.to_csv("data/exports/pop_data.csv", header=True, index=False)
pop_nat_sel.to_csv("data/exports/pop_nat_sel.csv", header=True, index=False)
df_gini_calcule.to_csv("data/exports/df_gini_calc.csv", header=True, index=False)

from fonctions_perso import duree_convert

# repère de fin de traitement du notebook
end_time_m4 = time.time()
duree_m4 = end_time_m4 - start_time_m4

duree = duree_convert(duree_m4)
print("Temps total d'exécution du notebook : "+str(duree))

Temps total d'exécution du notebook : 42s

Haut de page