<jupyter_start><jupyter_text>De l'importance de la Data Viz'   La visualisation des données (Data visualisation / Dataviz) est un domaine familier chez presque tous les data scientists et data analysts. Elle permet de tirer rapidement des informations et de simplifier leur lecture et leur intérprétation grâce aux représentations graphiques.-  Pourquoi faire de la Dataviz ?            Une image vaut mille mots            -  Pour l'exploration des donnéesVisualiser les données peut sembler superflu. Toutefois le cerveau humain assimile lus facilement les informations au format visuel que dans une autre forme. Tirer le meilleur parti de cette faculté est primordial pour un projet Data. En effet, les Data Scientists / Analysts ont souvent affaire à des quantités de données multidimensionnelles. Par conséquent, comprendre de telles quantités de données est possible grâce à la Data Visualization.-  Communiquer ses idéesNotre faculté naturelle à comprendre les données visuelles permet souvent, de faire passer un message complexe d’une façon aisée. Le Data scientist / Analyst est quelqu’un qui jongle entre les statistiques, la programmation et les données à haute dimension… mais communique aussi avec les décideurs de l’entreprise. Ces derniers n’ont pas forcément de grandes compétences techniques et la Dataviz permet de communiquer avec le Management.Pour communiquer de façon efficace, il n’y a pas mieux que de faire quelques visualisations et graphiques pour expliquer des tendances ou expliquer des résultats. Les décideurs et les gens du métier sont des personnes à l’aise avec des outils comme Excel qui permet de produire aisément des Dashboards et des graphiques. Par conséquent, le Data scientist / analyst a intérêt de profiter de ce terrain de compréhension commun pour véhiculer ses conclusions et ses idées.-  Statistiques vs DatavizLes statistiques permettent de résumer les caractéristiques principales d’un jeu de données à l’aide de métriques numériques. Cependant, se baser uniquement sur ces chiffres pour tirer des conclusions sur un jeu de données (ou une feature du jeu de données) peut conduire à des déductions erronées.C'est pourquoi on devrait combiner stats et viz plutôt que de les confronter l'un face à l'autre*Par ailleurs, Toutes les bibliothéques qui seront présentés durant cette formations sont très riche, toutes leurs fonctionnalités ne peuvent être traitées en une seule formation(ni 5). Cette formation fait le choix d'explorer certaines fonctions plus que d'autres, l'objectif général étant de vous rendre autonome sur ces modules en fin de formation.*  Matplotlib  Matplotlib est un puissant outil pour tracer des graphiques et visualiser des données en Python. Elle est destinée à produire des graphiques de toutes sortes<jupyter_code>%matplotlib inline
#afficher automatiquement les figures lors de l'exécution d'une cellule contenant un appel à une commande pyplot,.
import matplotlib.pyplot as plt
import matplotlib as mpl
import matplotlib.pylab as plt

import numpy as np
import pandas as pd

import sys

print('Matplotlib Version: ' + mpl.__version__)
print('NumPy Version: ' + np.version.full_version)
print('Python Version: ' + sys.version)<jupyter_output>Matplotlib Version: 3.2.1
NumPy Version: 1.18.2
Python Version: 3.6.9 (default, Jan 26 2021, 15:33:00) 
[GCC 8.4.0]<jupyter_text>Tracer une courbe   Une courbe est par définition un ensemble de points de coordonnées (x, y) reliés par une ligne brisée. Plus le nombre de points est important, plus la courbe aura un aspect lisse. La méthode plot()La méthode plot permet de tracer des courbes qui relient des points dont les abscisses et ordonnées sont fournies dans des listes ou tableaux.Pour tracer un graphe avec les valeurs 'x' en abscisses et les valeurs 'y' en ordonnées<jupyter_code>x = [0,2,3,6]
y = [1,4,4,8]
plt.plot(x,y); #(bleu)
plt.plot(x); #afficher en ordonées (orange), donc les ordonnées ont automatiquement pris [0,1,2,3]

plt.title('Le titre de ma courbe');
plt.xlabel("Abscisses");
plt.ylabel("Ordonnées");<jupyter_output><empty_output><jupyter_text>Il est possible de délimiter les domaines des abscisses et des ordonnées en utilisant la méthode axis.Elle s'utilise ainsi : axis([xmin, xmax, ymin, ymax]).Pour fixer indépendamment le domaines des abscisses ou des ordonnées on peut utiliser respectivement xlim([xmin, xmax]) ou ylim([ymin, ymax]).<jupyter_code>x = [0,2,3,6]
y = [1,4,4,8]
plt.plot(x,y); #(bleu)
plt.plot(x); #afficher en ordonées (orange), donc les ordonnées ont automatiquement pris [0,1,2,3]

plt.axis([1,3,1,5]);

plt.title('Le titre de ma courbe');
plt.xlabel("Abscisses");
plt.ylabel("Ordonnées");
plt.plot([0,0,1,1,0,0.5,1],[1,0,0,1,1,2,1])
plt.axis([-1,2,-1,2])
#plt.axis([-5,5,-5,5])<jupyter_output><empty_output><jupyter_text>Pour superposer plusieurs courbes sur le même graphique, on peut cumuler les instructions plot les unes après les autres, comme ceci :- plt.plot(x,y)- plt.plot(u,v)- plt.plot(w,z) ou simplement utiliser la syntaxe suivante:- plt.plot(x,y,u,v,w,z).<jupyter_code>t = np.arange(0,5,0.2)
plt.plot(t,t,t,t**2,t,t**3)
plt.ylim(0,5)<jupyter_output><empty_output><jupyter_text>Avec du style !Pour chaque paire (x,y) d'arguments, il y a un troisième argument optionnel qui est une chaîne de caractères qui indique le style et la couleur de la ligne de la courbe.  Les styles de courbes possibles sont:- '-' : ligne continue- '--' : tirets- ':' : ligne en pointillé- '-.' : tirets points L'ensemble des couleurs possibles est:- 'b' (bleu)- 'g' (vert) - 'r' (rouge) - 'c' (cyan) - 'm' (magenta) - 'y' (jaune) - 'k' (noir) - 'w' (blanc)`Par exemple, le format par défaut est ‘b-‘, qui est une ligne continue bleue.<jupyter_code>t = np.arange(0,5,0.2)
plt.plot(t,t,'r-.',t,t**2,'g:',t,t**3,'b--')
plt.ylim(0,5)<jupyter_output><empty_output><jupyter_text>Plus d'arguments optionels<jupyter_code>t = np.arange(0,5,0.2)
plt.plot(t,t,'r-.',label = ' linéiaire', linewidth=0.5)
plt.plot(t,t**2,'g:',label = 'carré', linewidth=2)
plt.plot(t,t**3,'b--',label = 'cubique', linewidth=3)
plt.ylim(0,5)
plt.grid(True) 
plt.xlabel(' X')
plt.ylabel(' Y')
plt.legend();<jupyter_output><empty_output><jupyter_text>Relation avec un DataFrame Pandas La fonction plot fonctionne également avec les Series de Pandas. Lorsque l'on travaille avec un DataFrame, on peut donc facilement en extraire les colonnes pour créer des graphiques.<jupyter_code>df=pd.read_csv('sales_phones.csv')
df
df.plot(x='week',y=['iphone_sales','samsung_sales','xiaomi_sales'],style=['c--','r-+','b-+'],title='Vente par semaine');
df=pd.read_csv('sales_data.csv')
df
plt.plot(df.Month,df.Product1);
#autre manière équivalente
df.plot(x = 'Month', y='Product1', title= "Ventes par mois");
plt.plot(df.Month,df.Product2,label="Produit 2");
plt.ylabel("Ventes");
plt.legend();<jupyter_output><empty_output><jupyter_text>Graphique en Bar  La fonction plt.bar permet de tracer des diagrammes en barres, verticaux avec une seule ou plusieurs séries de valeurs.Pour afficher un bar plot il suffit d'entrer dans la fonction en premier argument les positions de l'axe des abscisses sur lesquelles les barres seront centrées, et en second argument les hauteurs des barres.Les paramètres supplémentaires les plus importants sont: la couleur de l'intérieur des barres (color) et la largeur relative de chaque barre (width par défaut 0.8, c'est à dire 20% d'espace vide entre chaque barre).Comme toutes les fonctions de pyplot il existe beaucoup d'autres paramètres comme :edgecolor : la couleur des encadrements.linewidth : l'épaisseur des traits.yerr : les valeurs des barres d'erreur.ecolor : la couleur des barres d'erreur.align: l'axe des abscisses correspond au centre de la barre , ou au bord gauche.orientation : 'horizontal' pour afficher un barplot horizontal.hatch = '/' : les hachures. Valeurs possibles : '/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*'.<jupyter_code>plt.bar(range(7), [3,4,5,6,5,4,3], width=0.9);
plt.bar([1,3,5,7,9],[5,2,7,8,2], label="Exemple 1")
plt.bar([2,4,6,8,10],[8,6,2,5,6], label="Exemple 2")

plt.xlabel('Nombre')
plt.ylabel('Valeur')

plt.legend()

plt.title('Mon graphique en barres');
plt.bar(range(len(df.iphone_sales)),df.iphone_sales,width=1);
plt.bar(range(len(df.Product1)),df.Product1,color='g',label='Produit 1');
plt.ylabel("Ventes");
plt.xlabel("Mois");
plt.title("vente par mois du produit 1");
plt.legend();
plt.bar(range(len(df.Product1)),df.Product1,color='b',label="Produit 1");
plt.bar(range(len(df.Product2)),df.Product2,bottom = df.Product1, color='r',label="Produit 2");
plt.legend(title="Vente")
plt.xlabel('Mois')
plt.ylabel('Ventes')
plt.ylim(0,800)
plt.title('Comparaison des ventes entre les produits 1 et 2 ');
df.head(6).plot.bar(x = 'Month', y=['Product1', 'Product2', 'Returns'], stacked=True);<jupyter_output><empty_output><jupyter_text>Graphes en camenbert avec pyplot Les camemberts sont des diagrammes circulaires divisés par secteurs (wedges). C'est une manière efficace de représenter l'information lorsque l'on s'intéresse principalement à la comparaison d'un secteur avec le camembert tout entier plutôt qu'entre deux secteurs.La fonction pie permet de tracer des diagrammes circulaires à partir d'une séquence X.Chaque élément  xi  de X est représenté par une part proportionnelle à  xi /sum(X). Si la somme des éléments de X est inférieure à 1, le camembert est représenté à l'aide des valeurs de X directement, aucune normalisation n'est effectuée, ce qui laisse un espace vide.<jupyter_code>plt.figure(figsize = (6, 6))
x = [1, 2, 3, 4, 10]
plt.pie(x, labels = ['A', 'B', 'C', 'D', 'E'])
plt.legend();<jupyter_output><empty_output><jupyter_text>De nombreux paramètre permettent de customiser son camembert : - **explode**: liste de la même taille que la séquence de données, permet d'éloigner une ou plusieurs part du centre en indiquant de quelle fraction de rayon chaque part doit être éloignée (0 par défaut).- **colors**: séquence de couleurs à utiliser pour les parts.- **labeldistance** : la distance des labels au centre (> 1 pour être à l'extérieur du cercle).- **autopct** : une fonction lambda qui prend le pourcentage calculé pour une part et renvoie ce qui doit être affiché pour ce pourcentage.- **pctdistance** : la distance au centre à laquelle le pourcentage précédent doit être affiché (1 = sur le cercle).- **shadow** = True : indique qu'il faut afficher une ombre.<jupyter_code>plt.figure(figsize = (7, 7))

plt.pie(x = df.head(6).Turnover, labels = ['Janv', 'Fev', 'Mars', 'Avril', 'Mai', 'Juin'],
           colors = ['red', 'orange', 'yellow', 'green', 'blue', 'purple'],
           explode = [0, 0, 0, 0.2, 0, 0],
           autopct = lambda x: str(round(x, 2)) + '%',
           pctdistance = 0.7, labeldistance = 1.2,
           shadow = True)
plt.legend();<jupyter_output><empty_output><jupyter_text>Sous-graphes avec Subplots<jupyter_code>fig = plt.figure(figsize=(10,10))

plt.subplot(2,2,1)
plt.bar(range(len(df)), df.Product1, label = 'Product1')

plt.subplot(222)
plt.scatter(df.Product1, df.Product2, c = 'm', label = "Product2")

plt.subplot(223)
plt.plot(df.Returns,'r-*', label = "Returns")

plt.subplot(224)
plt.hist(df.Turnover, color='green', rwidth = 0.8, label = "Turnover");

t = np.arange(0.0, 2.0, 0.01)
# On crée la séquence de points entre 0 et 2, avec un pas de 0.01

plt.plot(t, np.cos(2*np.pi*t))
# On trace la courbe de la fonction f(t)cos(2*pi*t)
plt.ylim(-2,2)
# On délimite l'axe des ordonnées entre -2 et 2.

plt.text(0.8, 1.1, 'maximum local');
# On affiche le texte 'maximum local', au point (1.5, 1.1) du graphique.
plt.grid(True)

x = np.arange(0., 5., .01)

y = np.sin(2*np.pi*x) * np.exp(-x)
plt.plot(x, y)
plt.plot(x, np.exp(-x))
plt.plot(x, -np.exp(-x))

plt.annotate('Asymptote: exp(-x)', xy=(1.5, 0.25), xytext=(2, 0.5), 
            arrowprops={'facecolor':'green'} )
# On crée une flèche orientée vers le point (1.5, 0.25), avec l'annotation 'Assymptote: exp(-x)'
# qui débute au point(2, 0.5). Puis on lui donne la couleur verte.

plt.annotate('Assymptote: - exp(-x)', xy=(1.5, -0.25), xytext=(2, -0.5), 
            arrowprops={'facecolor':'red' } );
x = np.linspace(-6, 2, 40)
# On crée une séquence de 40 points dans l'intervalle [-6, 2]

plt.grid(True, linestyle = '--')
# On ajoute un quadrillage au graphique

plt.plot(x, x**2, 'b',label='$x^2$')
# On trace la courbe x^2 et on lui donne le label correspondant pour la légende.

plt.plot(x,np.exp(-x), 'g--', label='$exp(-x)$')
# On trace la courbe exp(-x) en pointillés et on lui donne le label correspondant pour la légende.

plt.axis([-5,2,0,25])
# On modifie l'amplitude des axes

plt.plot([-3, -2, -2, -3, -3],[5, 5, 10, 10, 5],'r', alpha = 0.6)
# On crée le carré qui entoure la partie du graphique que l'on va reproduire
# L'argument 'alpha' donne le pourcentage d'opacité du plot (1 opaque, 0 transparent invisible)

plt.annotate('Zoom', xy=(-1.8, 7.5), xytext=(-0.5, 7.5), 
            arrowprops={'facecolor':'red'} )
# On crée la flèche rouge, avec le texte 'Zoom' dirigé vers le point (-1.8, 7.5).

plt.title('Mon graphique bilan')
#On donne un titre au graphique

plt.legend()
# On affiche les légendes

plt.axes([.55, 0.4, .2, .2])
# On crée un nouveau graphique à l'intérieur du précédent,
# dont le coin en bas à gauche démarre au point (0.55, 0.4) en distance relative, 
# où 0 représente l'origine, et 1 le bout de l'axe.
# Ce graphique aura une largeur et une hauteur représentants 20% de la largeur 
# et de la hauteur du graphique d'origine.

#A partir de là, les commande 'pyplot' s'appliqueront uniquement à ce nouveau graphique.

plt.plot(x,x**2, 'b')
plt.plot(x,np.exp(-x), 'g--')
# On trace les mêmes courbes que précedemment.

plt.axis([-3,-2,5,10])
# Mais on limite les axes aux coordonnées du carré que l'on a tracé.

plt.xticks([])
plt.yticks([]);
# On supprime les graduations sur le nouveau graphique.<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12792455546756892, 'fraction_numerical': 0.02426031243251026, 'mean_word_length': 5.016457340840191, 'pattern_counts': {'":': 0, '<': 44, '<?xml version=': 0, '>': 45, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '11', 'dir': 'jupyter-structured-clean-dedup', 'id': '251395', 'license': 'Apache-2.0', 'n_tokens_mistral': 5217, 'n_tokens_neox': 5067, 'n_words': 1660, 'path': 'Matplotlib/.ipynb_checkpoints/Matplotlib-checkpoint.ipynb', 'repo_name': 'centraleIA/Data-Viz-Courses', 'size': '13891'}