<jupyter_start><jupyter_text>[(précédent)](03%20-%20-%20-%20Python%20-%20intermediate.ipynb) | [(index)](00%20-%20-%20-%20Introduction%20-%20to%20-%20Python.ipynb) | [(suivant)](05%20-%20-%20-%20Introduction%20-%20to%20-%20data%20-%20as%20-%20a%20-%20science.ipynb) Outils Python pour l'analyse de données    Objectifs d'apprentissages :                Identifier les concepts de raisonnement éthique qui peuvent influence nos analyses et les résultats des données.        Apprendre et mettre en application les méthodes de base des bibliothèques essentielles à l'analyse de données, Numpy, Pandas et Matplotlib.    Les données sont devenues le langage le plus important de notre époque - elles servent de source à l'intelligence des machine automatisées, à l'analyse prédictive des diagnostiques médicaux. La diminution rapide des coûts et la facilité d'accès aux besoins de base de ces systèmes - données, logiciels, calcul distribué, capteurs - conduisent à l'adoption et la croissance de la prise de décision bâtie sur des données. Comme il devient de plus en plus simple de collecter des données au sujet des individus et des systèmes, différents types de professionnels - qui n'ont jamais été formé sur ces besoins - se débattent avec des capacités insuffisantes pour l'analyse et la gestion de donées, ainsi que les risques éthiques émergeant de la possession et des conséquences de ces données et outils.Avant d'entamer la formation technique, quelques considérations éthiques sur l'utilisation des données. ÉthiqueLes ordinateurs ne prennent pas de décision. Ils fournissent des résultats dépendant strictement des données fournies en entrée et des algorithmes appliqués pour les analyser. L'assistance que les ordinateurs peuvent fournir pour la prise de décision ne remplace pas la responsibilité humaine.Les données et de les algorithmes utilisées pour justifier des décisions doivent pouvoir être passés en revue. "L'ordinateur a dit « non »" n'est pas une justification acceptable.Nos actions en tant que *data scientists* sont destinées à convaincre d'agir ou de penser autrement, sur la simple base de la crédibillité de notre analyse, et informé par les données.Les processus par lesquels nous examinons et expliquons ce que nous considérons comme  des comportements humains bons ou mauvais font partie de l'éthique.Cas d'usage: _Polygal_ est un gel fait à base de betterave et de pectine de pommes ; utilisé sur un patient sévèrement blessé, il était supposé réduire les  saignements. Pour vérifier cette hypothèse, [Sigmund Rascher](https://en.wikipedia.org/wiki/Sigmund_Rascher) l'utilisa sur des humains blessés par balle ou amputés sans anesthésie.Pendant la deuxième Guerre Mondiale, sous la direction d'officiers supérieurs Nazis, de très violentes expériences médicales furent pratiquées sur des prisonniers de guerre et des civils considérés comme sous-humains par le régime nazi. Après la guerre, 20 médecins furent jugés pour crimes de guerre et crimes contre l'humanité lors du [procès des médécins](https://en.wikipedia.org/wiki/Doctors%27_trial) tenu à Nuremberg de 1946 à 1949.En 1947 <NAME> - le chef adjoint de la santé du 3ème Reich, un scientifique nazi de haut rang - fut acquitté de crimes de guerre sur intervention musclée des États-Unis. Dans les deux mois suivants, l'armée américaine le debriefa pour apprendre tout ce qu'il savait sur les armes biologiques.Pensez vous que les État-Unis ont eu raison ou tort d'offrir à Blome l'immunité en échange de ses connaissances ?Nombre des expériences menées par les Nazis soulèvent des dilemmes éthiques, par exemple : l'immersion de prisonniers dans de l'eau glaciale pour observer le résultat et tester des techniques de sauvetage d'hypothermie ; des expérences de pression de haute altitude et de décompression ; des tests de sulfanilamide pour le traitement de gangrènes et autres infections bactériennes.Pensez vous qu'il serait acceptable ou pas d'utiliser ces données dans vos travaux de recherche et d'analyse ?    Pour en savoir plus.L'éthique fournit un cadre théorique pour décrire le monde non pas tel qu'il est, mais tel qu'il *devrait* ou *ne devrait pas* être. Cela permet de décrire un résultat idéal, et de consider tout ce que l'on connaît ou ne connaît pas qui puisse empêcher ou détourner le résultat désiré.impede or confound our desired result.Cas d'usage: Un homme nigérien voyage aux États-Unis. Après l'une des sessions, il va aux toilettes pour se laver les mains. Le distributeur automatique de savon ne reconnaît pas ses mains sous le détecteur. Un américan blanc le voit perdu et place ses propres mains sous l'appreil. Celui distribue due savon. Le Nigérien essaye à nouveau, mais l'appareil l'ignore à nouveau.Comment une telle chose peut se produire ? Y-a-t'il des considérations éthiques à l'affaire  ?Pour en savoir plus.Lorsque l'on considère des résultats éthiques, on utilise les termes *bon* ou *mauvais* pour décrire les jugements sur les gens ou les choses, et *juste* ou *injuste* pour décrire le résultats d'actions spécifiques. Il faut noter cependant que, si juste ou injuste est parfois évident, on se retrouve souvent face à des dilemmes éthiques.Pour déterminer si une action est juste ou non, il faut confronter la tension entre l'intention de l'action et ses conséquences. Est-ce que seules les intentions comptent ? Ou devrions nous seulement considérer les effets ? Et jusqu'à quelle limite doit on pousser les jugements de l'enchaînement suivant : une motivation juste_ menant à une intention _juste_, pour effectuer une ation _juste_ menant à uniquement de _bonnes_ conséquences. Comment évaluer cela face aux faits impossibles à déterminer au moment de la prise de décision ?Il convient aussi de considérer les intérêts en compétition pour ce qui consitue un effet positive ou négatif. A effedt positif pour l'individu prenant la décision peut se révéler une mauvaise décision pour bien d'autres. Inversement, une personne altruiste peut agir uniquement au bénéfice des autres à son propre détrimentLes problèmes éthiques n'exigent pas systétmatiquement une analyse des faits pour justifier une décision donnée, mais ils ont un certain nombre de caractéristiques : * _ public_ : le processus par lequel un choix éthique est effectué est connu de tous les participants ; * _ informel_ : le processus ne peut pas toujours être codifié en terme de loi ou de système légal ; * _rationnel_ : malgré l'informalité, la logique utilisée doit être accessible et pouvoir être défendue ; * _impartial_ : toute décision se doit de ne pas favoriser un groupe ou une personne en particulier.Plutôt que d'imposer une ensemble de règles à suivre, l'éthique fournir un cadre dans lequel on peut déterminer si nos objectifs sont conformes à nos valeurs, et si le processus par lequel nous prenons des décisions peut être validé et vérifié par d'autres personnes.Quel que soit le degré de sophistication que les machines atteindront, et à moins que nous visions à bâtir une société "de machines pour les machines", les humains seront toujours requis pour décider de quelles considérations éthiques doivent être prises en compte.Il y a des limites à ce que le travail d'analyse peut accomplir, et il est de la responsabilité des individus produisant cette analyse de s'assurer que les hypothèses, les doutes et le contexte soient documentés en même temps que les résultats. Il est particulièrement critique que chacun se sente responsible de soulever les inquiétudes qui pourraient exister autour des données source utilisées dans l'analyse, y compris si l'usage de données personnelles est légitime, ou si les données source et les algorithmes de traitement de ces données sont fiables,  L'analyse de donnéesCeci fournit une brève introduction à certains des outils d'analyse de données utilisé en Python. Cela ne couvre pas les approches à suivre pour l'analyse de données, qui devra être étudié séparément.. Les tableaux NumpyL'analyse de données requiert souvent d'effectuer des opérations sur de longues listes de données. Numpy est une suite d'outils puissante permettant de travailler rapidement et facilement avec des listes de données entières. Nous référerons à ces listes de données sous le nom de *array* (tableaux) - et si vous êtes familiers avec cette branche des mathématiques, vous pouvez imager ces fonctions comme s'appliquant à des matrices.La convention veut que l'import de Numpy se fasse sous l'étiquette np : `import numpy as np`.Nous allons aussi générer de nombreuses listes de nombre flottants aléatoires pour nos exercices. Nous allons utiliser Python à cette fin avec le module `random`.<jupyter_code>import numpy as np
import random

def generate_float_list(lwr, upr, num):
    """
    Return a list of num random decimal floats ranged between lwr and upr.
    
    Range(lwr, upr) creates a list of every integer between lwr and upr.
    random.sample takes num integers from the range list, chosen randomly.
    """
    int_list = random.sample(range(lwr, upr), num)
    return [x/100 for x in int_list]

# Crée deux listes
height = generate_float_list(100, 220, 10)
weight = generate_float_list(5000, 20000, 10)

# Convertir en Numpy arrays
np_height = np.array(height)
np_weight = np.array(weight)

print(np_height)
print(np_weight)<jupyter_output>[1.33 2.07 2.11 1.74 2.13 1.5  1.76 1.49 1.05 2.09]
[155.33 172.64 157.02 166.43 133.5  166.17 124.89 115.04 111.62 129.7 ]<jupyter_text>Les carnets de note Jupyter fournissent une fonction de chronométrage utile. En préfixant une ligne de code avec `%time`, vous obtiendrez le temps qu'à mis le code à tourner.Ceci est particulièrement important pour les opérations impliquant de lourds traitements de données pour lesquelles toute amélioration de performance peut s'avérer précieuse.Nous allons pouvoir maintenant effectuer des opérations directement sur l'ensemble des valeurs contenus dans les tableaux Numpy. Voici deux méthodes faciles à utiliser.    Syntaxe                Calculs sur tous les éléments : on peut traiter les tableaux Numpy tout comme s'il s'agissait d'entiers ou nombres flottants individuels. Pour cela, les talbeaux doivent avoir la même forme (à savoir, leur nombre d'éléments). On peut par ailleurs appliquer les opérations arithmétiques classiques avec un nombre simple (qui s'appliquent alors à chaque élément)            Filtrage : On peut filtrer rapidement les tableaux Numpy avec des opérations booléennes ; par exemple `np_array[np_array > num]` ; pour obtenir une réponse booléenne, `np_array > num`<jupyter_code># Calcul l'indice de masse corporel (IMC, BMI en anglais) en fonction des tailles et poids dans nos tableaux
# Chronométrez le calcul - cela ne prendra pas longtemps
%time bmi = np_weight / np_height ** 2

print(bmi)

# Un BMI > 35 indique une obésité sévère. Voyons qui est concerné dans notre échantillon

# Pour une réponse booléenne
print(bmi > 35)

# Ou pour lister seulement les valeurs du BMI au dessus de 35
print(bmi[bmi > 35])<jupyter_output>CPU times: user 67 µs, sys: 43 µs, total: 110 µs
Wall time: 270 µs
[ 87.81163435  40.29032183  35.26874958  54.97093407  29.42537856
  73.85333333  40.31831095  51.8174857  101.24263039  29.69254367]
[ True  True  True  True False  True  True  True  True False]
[ 87.81163435  40.29032183  35.26874958  54.97093407  73.85333333
  40.31831095  51.8174857  101.24263039]<jupyter_text>PandasNous avons brièvement essayer Pandas lors de [notre session sur les modules](03 - Python intermediate.ipynbBuilt-in-modules).La description donnée pour Pandas était alors :_**pandas** is a Python package providing fast, flexible, and expressive data structures designed to make working with "relational" or "labeled" data both easy and intuitive. It aims to be the fundamental high-level building block for doing practical, **real world** data analysis in Python. Additionally, it has the broader goal of becoming **the most powerful and flexible open source data analysis / manipulation tool available in any language**._soit_**pandas** est un paquet Python qui founrit des structures rapides, souples et expressives conçues pour rendre les opérations sur des données relationnelles ou étiquettées à la fois simple et intuitif. Il vise à être la brique fondamentale haute-niveau pour l'analyse de données concrète et pragmatique en Python. Il a par ailleurs le but plus large de devenir **le plus puissant et le plus souple outil d'analyse et de manipulation des données open-source de tous les langages de programmations**._Pandas est développé par [<NAME>](http://wesmckinney.com/) et est soutenu par une formidable et très active communauté de développemen. Wes préfère voir pandas écrit en minuscule.Pandas est bâti sur Numpy - ils sont donc fortement liés et intégrés. Pandas permet de manipuler des données soit sous forme de série (`Series`) (de manière semblable à Numpy mais avec des fonctionnalités supplémentaires), ou bien sous forme tabulaire avec des lignes de valeurs et des colonnes nommées (semblable à un tableau Excel).Cette forme tabulaire est appelée un `DataFrame`. Pandas fonctionne bien avec Jupyter Notebook et celui-ci permet d'afficher de manière satisfaisante - il faut pour cela s'assurer que la dernière ligne du bloc de code est le nom du `DataFrame`.Par convention, pandas est importé sous l'étiquette pd, `import pandas as pd`.Le tutoriel suivant est dérivé directement de 'pandas en 10 minutes' dans la [documentation de Pandas](https://pandas.pydata.org/pandas-docs/stable/10min.html). À noter que ceci ne reproduit l'intégralité du tutoriel qui peut être complété sur le site originel. Création d'objetsPour créer une `Series`, passez une liste de valeurs et laissez pandas créer un index d'entiers par défaut.<jupyter_code>import pandas as pd
import numpy as np

s = pd.Series([1,3,5,np.nan,6,8])
s<jupyter_output><empty_output><jupyter_text>Notez que `np.nan` est la manière dont Numpy représente la valeur "pas-un-nombre" (nan pour "not a number"). Par exemple, une division par zéro renvoie `np.nan`. Cela permet d'effectuer des opérations complexes de manière protégée et de gérer les dégâts après coup.Créons un `DataFrame` en utilisant un tableau numpy, avec une index horodaté et des colonnes étiquetées.<jupyter_code># Créons une liste de dates formattées ISO (YYYYMMDD)
dates = pd.date_range('20130101', periods=6)
dates
# Créons un DataFrame qui utilise cette liste de données comme index
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
df<jupyter_output><empty_output><jupyter_text>Il est aussi possible d'ajouter des données textuelles et numériques avec un index généré automatiquement.<jupyter_code>dict = {"country": ["Brazil", "Russia", "India", "China", "South Africa"],
       "capital": ["Brasilia", "Moscow", "New Dehli", "Beijing", "Pretoria"],
       "area": [8.516, 17.10, 3.286, 9.597, 1.221],
       "population": [200.4, 143.5, 1252, 1357, 52.98] }

brics = pd.DataFrame(dict)
brics<jupyter_output><empty_output><jupyter_text>Les nombres à gauche du teableau forment l'index. Celui-ci permet de faire référence à une ligne donnée. Il est cependant possible d'utiliser votre propre index avec pandas. On pourrait utiliser l'une des colonnes existantes comme index (du moment qu'elle ne contient que des valeurs uniques) ou ajour un index spécialisé.<jupyter_code># Utilisons le code pays ISO à deux lettres comme index
brics.index = ["BR", "RU", "IN", "CH", "SA"]

brics<jupyter_output><empty_output><jupyter_text>Visualiser les donnéesPandas fonctionne avec des jeux de données extrêment larges, y compris plusieurs millions de lignes. Afficher de telles données demande beaucoup d'espace et, pour avoir juste un aperçu de ces données (puisqu'en général, nous travaillerons dessus de manière symbolique), cela peut s'avérer déplaisant. Heureusement, pandas fournir un certain nombre de façons de visualiser et passer en revue les données    Syntaxe                Voir les lignes du haut et du bas de votre tableau (dataframe) avec `df.head()` ou `df.tail(num)` dans lequel `num` est le nombre de lignes à afficher        Voir l'index, les colonnes et les données numpy sous-jacentes avec `df.index`, `df.columns` et `df.values`        Obtenir un résumé statisque de vos données avec `df.describe()`        Transposer les données (i.e. échanger les lignes et les colonnes) avec `df.T`        Trier suivant un axe avec  `df.sort_index(axis=1, ascending=False)` où `axis=1` signifie l'axe des colonnes, et  `axis=0` les lignes        Trier par valeur avec `df.sort_values(by=column)`<jupyter_code># Head (tête de liste)
df.head()
# Tail (queue)
df.tail(3)
# Index
df.index
# Values (valeurs)
df.values
# Résumé statisque
df.describe()
# Transpose
df.T
# Tri suivant un axe
df.sort_index(axis=1, ascending=False)
# Tri des valeurs
df.sort_values(by="B")<jupyter_output><empty_output><jupyter_text>SélectionsUne des premières étapes en analyse des données est tout simplement de filtrer les données et d'obtenir les morceaux qui nous intéressent le plus.Pandas fournit de nombres approches pour restreindre rapidement les données à ce que l'on désire.    Syntaxe                Sélectionner une seule colonne en faisant référence au dataframe comme à un dictionnaire, avec `df[column]` ou bien, si la conne est en un seul mot, avec `df.column`. Cela renvoie une `Series`        Sélectionner une tranche de manière similaire à la méthode utilisée pour une liste Python, avec `df[]`, par exemple `df[:3]`, ou par indice, `df["20130102":"20130104"]`        Utiliser `.loc` pour sélectionner par étiquette, tel que :                    Obtenir une ligne via une étiquette, par exemple `df.loc[index[0]]`            Obtenir une sélection sur plusieurs axes avec une étiquette avec `df.loc[:, ["A", "B"]]` où le premier `:` indique une tranche de lignes, et la deuxième liste  `["A", "B"]` indique une liste de colonnes                Comme avec  Numpy, on peut obtenir une sélection à base de booléeans avec par ex. `df[df.A > num]`    Il y a _beaucoup_ plus de façon de filtrer les données et d'y accéder, de même que de nombreuses méthodes pour affecter des données dans les tableaux `DataFrame` , mais ceci devrait suffire pour le moment.<jupyter_code># By column
df.A
# By slice
df["20130102":"20130104"]
# Cross-section
df.loc[dates[0]]
# Multi-axis
df.loc[:, ["A", "B"]]
# Boolean indexing
df[df.A > 0]<jupyter_output><empty_output><jupyter_text>MatplotlibDans cette dernière section, nous allons faire connaissance avec _Matplotlib_, une bibliothèque puissante et largement utilisée pour les représentations graphiques en Python. Jupyter Notebook fournit une instruction "magique" pour créer des graphes directement dans un carnet de vote avec la commande `%matplotlib inline`.Matplotlib, Numpy et Pandas forment un trio incontournable de l'anayse de données.Gardez bien en tête que ceci est une introduction très limitée aux capacités de ces bibliothèques.<jupyter_code>import matplotlib.pyplot as plt
# Ceci permettra que les graphes de Matplotlib s'affichent directement dans le carnet de note Jupyter
%matplotlib inline

# Produce a random timeseries
ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))

# Get the cumulative sum of the random numbers generated to mimic a historic data series
ts = ts.cumsum()

# And magically plot
ts.plot()
# De même avec un tableau DataFrame
df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,
                  columns=['A', 'B', 'C', 'D'])

df = df.cumsum()

# And plot, this time creating a figure and adding a plot and legend to it
plt.figure()
df.plot()
plt.legend(loc='best')<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup