Comment décrire vos données – Real Python

By | décembre 16, 2019

Formation gratuite Python

À l'ère des mégadonnées et de l'intelligence artificielle, la science des données et l'apprentissage automatique sont devenus essentiels dans de nombreux domaines de la science et de la technologie. Un aspect nécessaire du travail avec les données est la capacité de décrire, résumer et représenter visuellement les données. Bibliothèques de statistiques Python sont des outils complets, populaires et largement utilisés qui vous aideront à travailler avec les données.

Dans ce didacticiel, vous apprendrez:

  • Quoi grandeurs numériques vous pouvez utiliser pour décrire et résumer vos ensembles de données
  • Comment calculer statistiques descriptives en Python pur
  • Comment avoir statistiques descriptives avec les bibliothèques Python disponibles
  • Comment visualiser vos jeux de données

Comprendre les statistiques descriptives

Statistiques descriptives consiste à décrire et résumer des données. Il utilise deux approches principales:

  1. L'approche quantitative décrit et résume les données numériquement.
  2. L'approche visuelle illustre les données avec des graphiques, des graphiques, des histogrammes et d'autres graphiques.

Vous pouvez appliquer des statistiques descriptives à un ou plusieurs ensembles de données ou variables. Lorsque vous décrivez et résumez une seule variable, vous effectuez analyse univariée. Lorsque vous recherchez des relations statistiques entre deux variables, vous effectuez une analyse bivariée. De même, un analyse multivariée s'intéresse à plusieurs variables à la fois.

Types de mesures

Dans ce didacticiel, vous découvrirez les types de mesures suivants dans les statistiques descriptives:

  • Tendance centrale vous indique les centres des données. Les mesures utiles incluent la moyenne, la médiane et le mode.
  • Variabilité vous informe sur la diffusion des données. Les mesures utiles comprennent la variance et l'écart-type.
  • Corrélation ou variabilité articulaire vous indique la relation entre une paire de variables dans un ensemble de données. Les mesures utiles incluent la covariance et le coefficient de corrélation.

Vous apprendrez à comprendre et à calculer ces mesures avec Python.

Population et échantillons

En statistiques, le population est un ensemble de tous les éléments ou éléments qui vous intéressent. Les populations sont souvent vastes, ce qui les rend inappropriées pour collecter et analyser des données. C’est pourquoi les statisticiens essaient généralement de tirer des conclusions sur une population en choisissant et en examinant un sous-ensemble représentatif de cette population.

Ce sous-ensemble d'une population est appelé échantillon. Idéalement, l'échantillon devrait préserver les caractéristiques statistiques essentielles de la population dans une mesure satisfaisante. De cette façon, vous pourrez utiliser l'échantillon pour glaner des conclusions sur la population.

Valeurs aberrantes

Un valeur aberrante est un point de données qui diffère considérablement de la majorité des données tirées d'un échantillon ou d'une population. Il existe de nombreuses causes possibles de valeurs aberrantes, mais voici quelques-unes pour commencer:

  • Variation naturelle dans les données
  • Changement dans le comportement du système observé
  • les erreurs dans la collecte de données

Les erreurs de collecte de données sont une cause particulièrement importante de valeurs aberrantes. Par exemple, les limites des instruments ou procédures de mesure peuvent signifier que les données correctes ne sont tout simplement pas disponibles. D'autres erreurs peuvent être causées par des erreurs de calcul, une contamination des données, une erreur humaine, etc.

Il n’existe pas de définition mathématique précise des valeurs aberrantes. Vous devez vous fier à l'expérience, aux connaissances sur le sujet d'intérêt et au bon sens pour déterminer si un point de données est une valeur aberrante et comment le gérer.

Choix des bibliothèques de statistiques Python

Il existe de nombreuses bibliothèques de statistiques Python avec lesquelles vous pouvez travailler, mais dans ce didacticiel, vous découvrirez certaines des plus populaires et des plus utilisées:

  • Python statistiques est une bibliothèque Python intégrée pour les statistiques descriptives. Vous pouvez l'utiliser si vos jeux de données ne sont pas trop volumineux ou si vous ne pouvez pas compter sur l'importation d'autres bibliothèques.

  • NumPy est une bibliothèque tierce pour le calcul numérique, optimisée pour travailler avec des tableaux unidimensionnels et multidimensionnels. Son type principal est le type de tableau appelé ndarray. Cette bibliothèque contient de nombreuses routines d'analyse statistique.

  • SciPy est une bibliothèque tierce pour le calcul scientifique basée sur NumPy. Il offre des fonctionnalités supplémentaires par rapport à NumPy, notamment scipy.stats pour l'analyse statistique.

  • Pandas est une bibliothèque tierce pour le calcul numérique basée sur NumPy. Il excelle dans la gestion des données unidimensionnelles (1D) étiquetées avec Séries objets et données bidimensionnelles (2D) avec Trame de données objets.

  • Matplotlib est une bibliothèque tierce pour la visualisation des données. Il fonctionne bien en combinaison avec NumPy, SciPy et Pandas.

Notez que, dans de nombreux cas, Séries et Trame de données les objets peuvent être utilisés à la place des tableaux NumPy. Souvent, vous pouvez simplement les transmettre à une fonction statistique NumPy ou SciPy. De plus, vous pouvez obtenir les données non étiquetées d'un Séries ou Trame de données comme un np.ndarray objet en appelant .valeurs ou .to_numpy ().

Premiers pas avec les bibliothèques de statistiques Python

Le Python intégré statistiques La bibliothèque possède un nombre relativement faible des fonctions statistiques les plus importantes. La documentation officielle est une ressource précieuse pour trouver les détails. Si vous êtes limité au Python pur, alors le Python statistiques bibliothèque pourrait être le bon choix.

Un bon endroit pour commencer à découvrir NumPy est le Guide de l'utilisateur officiel, en particulier les sections de démarrage rapide et de base. La référence officielle peut vous aider à rafraîchir votre mémoire sur des concepts NumPy spécifiques. Pendant que vous lisez ce tutoriel, vous voudrez peut-être consulter la section des statistiques et le scipy.stats référence aussi.

Si vous voulez apprendre les pandas, la page officielle de mise en route est un excellent endroit pour commencer. L'introduction aux structures de données peut vous aider à en savoir plus sur les types de données fondamentaux, Séries et Trame de données. De même, l'excellent tutoriel d'introduction officiel vise à vous donner suffisamment d'informations pour commencer à utiliser efficacement les Pandas dans la pratique.

matplotlib propose un guide de l'utilisateur officiel complet que vous pouvez utiliser pour vous plonger dans les détails de l'utilisation de la bibliothèque. Anatomy of Matplotlib est une excellente ressource pour les débutants qui souhaitent commencer à travailler avec matplotlib et ses bibliothèques associées.

Commençons par utiliser ces bibliothèques de statistiques Python!

Calcul des statistiques descriptives

Commencez par importer tous les packages dont vous aurez besoin:

>>>

>>> importation math
>>> importation statistiques
>>> importation engourdi comme np
>>> importation scipy.stats
>>> importation pandas comme pd

Ce sont tous les packages dont vous aurez besoin pour les calculs de statistiques Python. Habituellement, vous n'utiliserez pas la fonction intégrée de Python math package, mais il sera utile dans ce didacticiel. Plus tard, vous importerez matplotlib.pyplot pour la visualisation des données.

Créons des données avec lesquelles travailler. Vous commencerez par des listes Python qui contiennent des données numériques arbitraires:

>>>

>>> X = [[[[8.0, 1, 2,5, 4, 28,0]
>>> x_with_nan = [[[[8.0, 1, 2,5, math.nan, 4, 28,0]
>>> X
[8.0, 1, 2.5, 4, 28.0]
>>> x_with_nan
[8.0, 1, 2.5, nan, 4, 28.0]

Vous avez maintenant les listes X et x_with_nan. Ils sont presque les mêmes, à la différence près x_with_nan contient un nan valeur. Il est important de comprendre le comportement des routines de statistiques Python lorsqu'elles rencontrent un valeur non numérique (nan). En science des données, les valeurs manquantes sont courantes et vous les remplacerez souvent par nan.

Maintenant, créez np.ndarray et pd.Series objets qui correspondent à X et x_with_nan:

>>>

>>> y, y_with_nan = np.tableau(X), np.tableau(x_with_nan)
>>> z, z_with_nan = pd.Séries(X), pd.Séries(x_with_nan)
>>> y
tableau ([ 8. ,  1. ,  2.5, 4. , 28. ])
>>> y_with_nan
tableau ([ 8. ,  1. ,  2.5,  nan,  4. , 28. ])
>>> z
0 8,0
1 1,0
2 2,5
3 4,0
4 28,0
dtype: float64
>>> z_with_nan
0 8,0
1 1,0
2 2,5
3 NaN
4 4,0
5 28,0
dtype: float64

Vous avez maintenant deux tableaux NumPy (y et y_with_nan) et deux Pandas Séries (z et z_with_nan). Tous ces éléments sont des séquences de valeurs 1D.

Vous pouvez éventuellement spécifier une étiquette pour chaque valeur dans z et z_with_nan.

Mesures de tendance centrale

le mesures de tendance centrale afficher les valeurs centrales ou intermédiaires des jeux de données. Il existe plusieurs définitions de ce qui est considéré comme le centre d'un ensemble de données. Dans ce didacticiel, vous apprendrez à identifier et à calculer ces mesures de tendance centrale:

  • Signifier
  • Moyenne pondérée
  • Moyenne géométrique
  • Moyenne harmonique
  • Médian
  • Mode

Signifier

le échantillon moyen, également appelé échantillon de moyenne arithmétique ou simplement moyenne, est la moyenne arithmétique de tous les éléments d'un ensemble de données. La moyenne d'un ensemble de données est exprimée mathématiquement par Σᵢᵢ / , où = 1, 2,…, . En d'autres termes, c'est la somme de tous les éléments ᵢ divisée par le nombre d'éléments dans l'ensemble de données .

Cette figure illustre la moyenne d'un échantillon avec cinq points de données:

Statistiques Python

Les points verts représentent les points de données 1, 2,5, 4, 8 et 28. La ligne pointillée rouge est leur moyenne, ou (1 + 2,5 + 4 + 8 + 28) / 5 = 8,7.

Vous pouvez calculer la moyenne avec Python pur en utilisant somme() et len (), sans importer de bibliothèques:

>>>

>>> signifier_ = somme(X) / len(X)
>>> signifier_
8.7

Bien que cela soit propre et élégant, vous pouvez également appliquer des fonctions de statistiques Python intégrées:

>>>

>>> signifier_ = statistiques.signifier(X)
>>> signifier_
8.7
>>> signifier_ = statistiques.fmean(X)
>>> signifier_
8.7

Vous avez appelé les fonctions signifier() et fmean () du Python intégré statistiques bibliothèque et a obtenu le même résultat que vous avez fait avec Python pur. fmean () est introduit dans Python 3.8 comme une alternative plus rapide à signifier(). Il renvoie toujours un nombre à virgule flottante.

Cependant, s'il y a nan valeurs parmi vos données, puis statistics.mean () et statistics.fmean () reviendra nan comme sortie:

>>>

>>> signifier_ = statistiques.signifier(x_with_nan)
>>> signifier_
nan
>>> signifier_ = statistiques.fmean(x_with_nan)
>>> signifier_
nan

Ce résultat est cohérent avec le comportement de somme(), car somme (x_with_nan) renvoie également nan.

Si vous utilisez NumPy, vous pouvez obtenir la moyenne avec np.mean ():

>>>

>>> signifier_ = np.signifier(y)
>>> signifier_
8.7

Dans l'exemple ci-dessus, signifier() est une fonction, mais vous pouvez utiliser la méthode correspondante .signifier() ainsi que:

>>>

>>> signifier_ = y.signifier()
>>> signifier_
8.7

La fonction signifier() et méthode .signifier() de NumPy renvoie le même résultat que statistics.mean (). C’est également le cas lorsqu’il nan valeurs parmi vos données:

>>>

>>> np.signifier(y_with_nan)
nan
>>> y_with_nan.signifier()
nan

Vous n'avez souvent pas besoin de nan en conséquence. Si vous préférez ignorer nan valeurs, alors vous pouvez utiliser np.nanmean ():

>>>

>>> np.nanmean(y_with_nan)
8.7

nanmean () ignore tout simplement nan valeurs. Il renvoie la même valeur que signifier() si vous deviez l'appliquer à l'ensemble de données sans le nan valeurs.

pd.Series les objets ont également la méthode .signifier():

>>>

>>> signifier_ = z.signifier()
>>> signifier_
8.7

Comme vous pouvez le voir, il est utilisé de la même manière que dans le cas de NumPy. cependant, .signifier() des Pandas ignore nan valeurs par défaut:

>>>

>>> z_with_nan.signifier()
8.7

Ce comportement est le résultat de la valeur par défaut du paramètre facultatif skipna. Vous pouvez modifier ce paramètre pour modifier le comportement.

Moyenne pondérée

le moyenne pondérée, également appelé moyenne arithmétique pondérée ou moyenne pondérée, est une généralisation de la moyenne arithmétique qui vous permet de définir la contribution relative de chaque point de données au résultat.

Vous en définissez un poids ᵢ pour chaque point de données ᵢ de l'ensemble de données , où = 1, 2,…, et est le nombre d'éléments dans . Ensuite, vous multipliez chaque point de données avec le poids correspondant, additionnez tous les produits et divisez la somme obtenue par la somme des poids: Σᵢ (ᵢᵢ) / Σᵢᵢ.

La moyenne pondérée est très pratique lorsque vous avez besoin de la moyenne d'un ensemble de données contenant des éléments qui se produisent avec des fréquences relatives données. Par exemple, supposons que vous ayez un ensemble dans lequel 20% de tous les éléments sont égaux à 2, 50% des éléments sont égaux à 4 et les 30% restants des éléments sont égaux à 8. Vous pouvez calculer la moyenne de un tel ensemble comme celui-ci:

>>>

>>> 0,2 * 2 + 0,5 * 4 + 0,3 * 8
4.8

Ici, vous prenez en compte les fréquences avec les poids. Avec cette méthode, vous n'avez pas besoin de connaître le nombre total d'articles.

Vous pouvez implémenter la moyenne pondérée en Python pur en combinant somme() soit intervalle() ou Zip *: français():

>>>

>>> X = [[[[8.0, 1, 2,5, 4, 28,0]
>>> w = [[[[0,1, 0,2, 0,3, 0,25, 0,15]
>>> wmean = somme(w[[[[je] * X[[[[je] pour je dans intervalle(len(X))) / somme(w)
>>> wmean
6,95
>>> wmean = somme(X_ * w_ pour (X_, w_) dans Zip *: français(X, w)) / somme(w)
>>> wmean
6,95

Encore une fois, il s'agit d'une implémentation propre et élégante où vous n'avez pas besoin d'importer de bibliothèques.

Cependant, si vous avez de grands ensembles de données, alors NumPy est susceptible de fournir une meilleure solution. Vous pouvez utiliser np.average () pour obtenir la moyenne pondérée des tableaux NumPy ou Pandas Séries:

>>>

>>> y, z, w = np.tableau(X), pd.Séries(X), np.tableau(w)
>>> wmean = np.moyenne(y, poids=w)
>>> wmean
6,95
>>> wmean = np.moyenne(z, poids=w)
>>> wmean
6,95

Le résultat est le même que dans le cas de l'implémentation Python pure. Vous pouvez également utiliser cette méthode sur des listes et des tuples ordinaires.

Une autre solution consiste à utiliser le produit élément par élément w * y avec np.sum () ou .somme():

>>>

>>> (w * y).somme() / w.somme()
6,95

C'est ça! Vous avez calculé la moyenne pondérée.

Cependant, soyez prudent si votre jeu de données contient nan valeurs:

>>>

>>> w = np.tableau([[[[0,1, 0,2, 0,3, 0,0, 0,2, 0,1])
>>> (w * y_with_nan).somme() / w.somme()
nan
>>> np.moyenne(y_with_nan, poids=w)
nan
>>> np.moyenne(z_with_nan, poids=w)
nan

Dans ce cas, moyenne() résultats nan, ce qui est conforme à np.mean ().

Moyenne harmonique

le moyenne harmonique est l'inverse de la moyenne des inverses de tous les éléments de l'ensemble de données: / Σᵢ (1 / ᵢ), où = 1, 2,…, et est le nombre d'éléments de l'ensemble de données . Une variante de l'implémentation Python pure de la moyenne harmonique est la suivante:

>>>

>>> hmean = len(X) / somme(1 / article pour article dans X)
>>> hmean
2,7613412228796843

C'est assez différent de la valeur de la moyenne arithmétique pour les mêmes données X, que vous avez calculé à 8,7.

Vous pouvez également calculer cette mesure avec statistics.harmonic_mean ():

>>>

>>> hmean = statistiques.moyenne harmonique(X)
>>> hmean
2,7613412228796843

L'exemple ci-dessus montre une implémentation de statistics.harmonic_mean (). Si tu as un nan valeur dans un ensemble de données, puis il retournera nan. S'il y a au moins un 0, puis il reviendra 0. Si vous fournissez au moins un nombre négatif, vous obtiendrez statistics.StatisticsError:

>>>

>>> statistiques.moyenne harmonique(x_with_nan)
nan
>>> statistiques.moyenne harmonique([[[[1, 0, 2])
0
>>> statistiques.moyenne harmonique([[[[1, 2, -2])  # Augmente StatisticsError

Gardez ces trois scénarios à l'esprit lorsque vous utilisez cette méthode!

Une troisième façon de calculer la moyenne harmonique consiste à utiliser scipy.stats.hmean ():

>>>

>>> scipy.Statistiques.hmean(y)
2,7613412228796843
>>> scipy.Statistiques.hmean(z)
2,7613412228796843

Encore une fois, il s'agit d'une implémentation assez simple. Cependant, si votre jeu de données contient nan, 0, un nombre négatif ou autre chose que des nombres positifs, vous obtiendrez un ValueError!

Moyenne géométrique

le Moyenne géométrique est la -ème racine du produit de tous les éléments ᵢ dans un ensemble de données : ⁿ√ (Πᵢᵢ), où = 1, 2,…, . La figure suivante illustre les moyennes arithmétiques, harmoniques et géométriques d'un ensemble de données:

Statistiques Python

Encore une fois, les points verts représentent les points de données 1, 2,5, 4, 8 et 28. La ligne pointillée rouge est la moyenne. La ligne pointillée bleue est la moyenne harmonique et la ligne pointillée jaune est la moyenne géométrique.

Vous pouvez implémenter la moyenne géométrique en Python pur comme ceci:

>>>

>>> gmean = 1
>>> pour article dans X:
...     gmean * = article
...
>>> gmean ** = 1 / len(X)
>>> gmean
4.677885674856041

Comme vous pouvez le voir, la valeur de la moyenne géométrique, dans ce cas, diffère considérablement des valeurs des moyennes arithmétique (8.7) et harmonique (2.76) pour le même ensemble de données X.

Introduction de Python 3.8 statistics.geometric_mean (), qui convertit toutes les valeurs en nombres à virgule flottante et renvoie leur moyenne géométrique:

>>>

>>> gmean = statistiques.Moyenne géométrique(X)
>>> gmean
4.67788567485604

Vous avez obtenu le même résultat que dans l'exemple précédent, mais avec une erreur d'arrondi minimale.

Si vous transmettez des données avec nan valeurs, puis statistics.geometric_mean () se comportera comme la plupart des fonctions similaires et retournera nan:

>>>

>>> gmean = statistiques.Moyenne géométrique(x_with_nan)
>>> gmean
nan

En effet, cela est cohérent avec le comportement des statistics.mean (), statistics.fmean (), et statistics.harmonic_mean (). S'il y a un nombre nul ou négatif parmi vos données, alors statistics.geometric_mean () augmentera la statistics.StatisticsError.

Vous pouvez également obtenir la moyenne géométrique avec scipy.stats.gmean ():

>>>

>>> scipy.Statistiques.gmean(y)
4.67788567485604
>>> scipy.Statistiques.gmean(z)
4.67788567485604

Vous avez obtenu le même résultat qu'avec l'implémentation Python pure.

Si tu as nan valeurs dans un ensemble de données, puis gmean () reviendra nan. S'il y a au moins un 0, puis il reviendra 0,0 et donner un avertissement. Si vous fournissez au moins un nombre négatif, vous obtiendrez nan et l'avertissement.

Médian

le échantillon médian est l'élément central d'un ensemble de données trié. L'ensemble de données peut être trié par ordre croissant ou décroissant. Si le nombre d'éléments de l'ensemble de données est impair, alors la médiane est la valeur à la position médiane: 0,5 ( + 1). Si est pair, alors la médiane est la moyenne arithmétique des deux valeurs au milieu, c'est-à-dire les éléments aux positions 0,5 et 0,5 + 1.

Par exemple, si vous avez les points de données 2, 4, 1, 8 et 9, la valeur médiane est 4, qui se trouve au milieu de l'ensemble de données trié (1, 2, 4, 8, 9). Si les points de données sont 2, 4, 1 et 8, alors la médiane est 3, qui est la moyenne des deux éléments médians de la séquence triée (2 et 4). La figure suivante illustre cela:

Statistiques Python

Les points de données sont les points verts et les lignes violettes indiquent la médiane de chaque ensemble de données. La valeur médiane de l'ensemble de données supérieur (1, 2,5, 4, 8 et 28) est 4. Si vous supprimez la valeur aberrante 28 de l'ensemble de données inférieur, la médiane devient la moyenne arithmétique entre 2,5 et 4, qui est 3,25.

La figure ci-dessous montre à la fois la moyenne et la médiane des points de données 1, 2.5, 4, 8 et 28:

Statistiques Python

Encore une fois, la moyenne est la ligne pointillée rouge, tandis que la médiane est la ligne violette.

La principale différence entre le comportement de la moyenne et de la médiane est liée à l'ensemble de données valeurs aberrantes ou extrêmes. La moyenne est fortement affectée par les valeurs aberrantes, mais la médiane ne dépend que des valeurs aberrantes soit légèrement, soit pas du tout. Considérez la figure suivante:

Statistiques Python

Le jeu de données supérieur contient à nouveau les éléments 1, 2,5, 4, 8 et 28. Sa moyenne est de 8,7 et la médiane est de 5, comme vous l'avez vu précédemment. Le jeu de données inférieur montre ce qui se passe lorsque vous déplacez le point le plus à droite avec la valeur 28:

  • Si vous augmentez sa valeur (déplacez-le vers la droite), alors la moyenne augmentera, mais la valeur médiane ne changera jamais.
  • Si vous diminuez sa valeur (déplacez-la vers la gauche), alors la moyenne chutera, mais la médiane restera la même jusqu'à ce que la valeur du point mobile soit supérieure ou égale à 4.

Vous pouvez comparer la moyenne et la médiane comme un moyen de détecter les valeurs aberrantes et l'asymétrie dans vos données. Que la valeur moyenne ou la valeur médiane vous soit plus utile dépend du contexte de votre problème particulier.

Voici l'une des nombreuses implémentations Python pures possibles de la médiane:

>>>

>>> n = len(X)
>>> si n % 2:
...     médian_ = trié(X)[[[[rond(0,5*(n-1))]
... autre:
...     x_ord, indice = trié(X), rond(0,5 * n)
...     médian_ = 0,5 * (x_ord[[[[indice-1] + x_ord[[[[indice])
...
>>> médian_
4

Les deux étapes les plus importantes de cette implémentation sont les suivantes:

  1. Tri les éléments de l'ensemble de données
  2. Découverte les éléments du milieu dans le jeu de données trié

Vous pouvez obtenir la médiane avec statistics.median ():

>>>

>>> médian_ = statistiques.médian(X)
>>> médian_
4
>>> médian_ = statistiques.médian(X[:[:[:[:-1])
>>> médian_
3,25

La version triée de X est [1, 2.5, 4, 8.0, 28.0], donc l'élément au milieu est 4. La version triée de X[:-1], lequel est X sans le dernier élément 28,0, est [1, 2.5, 4, 8.0]. Maintenant, il y a deux éléments intermédiaires, 2,5 et 4. Leur moyenne est 3,25.

median_low () et median_high () sont deux autres fonctions liées à la médiane dans le Python statistiques bibliothèque. Ils retournent toujours un élément de l'ensemble de données:

  • Si le nombre d'éléments est impair, il n'y a qu'une seule valeur moyenne, donc ces fonctions se comportent comme médian().
  • Si le nombre d'éléments est pair, alors il y a deux valeurs moyennes. Dans ce cas, median_low () renvoie le plus bas et median_high () la valeur moyenne plus élevée.

Vous pouvez utiliser ces fonctions comme vous le feriez médian():

>>>

>>> statistiques.median_low(X[:[:[:[:-1])
2,5
>>> statistiques.median_high(X[:[:[:[:-1])
4

Encore une fois, la version triée de X[:-1] est [1, 2.5, 4, 8.0]. Les deux éléments du milieu sont 2,5 (faible) et 4 (haute).

Contrairement à la plupart des autres fonctions de Python statistiques bibliothèque, médian(), median_low (), et median_high () ne reviens pas nan quand il y a nan valeurs parmi les points de données:

>>>

>>> statistiques.médian(x_with_nan)
6.0
>>> statistiques.median_low(x_with_nan)
4
>>> statistiques.median_high(x_with_nan)
8.0

Méfiez-vous de ce comportement car ce n'est peut-être pas ce que vous voulez!

Vous pouvez également obtenir la médiane avec np.median ():

>>>

>>> médian_ = np.médian(y)
>>> médian_
4,0
>>> médian_ = np.médian(y[:[:[:[:-1])
>>> médian_
3,25

Vous avez obtenu les mêmes valeurs avec statistics.median () et np.median ().

Cependant, s'il y a un nan valeur dans votre ensemble de données, puis np.median () émet le RuntimeWarning et retourne nan. Si ce comportement n'est pas celui que vous souhaitez, vous pouvez utiliser nanmedian () tout ignorer nan valeurs:

>>>

>>> np.nanmedian(y_with_nan)
4,0
>>> np.nanmedian(y_with_nan[:[:[:[:-1])
3,25

Les résultats obtenus sont les mêmes qu'avec statistics.median () et np.median () appliqué aux jeux de données X et y.

Pandas Séries les objets ont la méthode .médian() qui ignore nan valeurs par défaut:

>>>

>>> z.médian()
4,0
>>> z_with_nan.médian()
4,0

Le comportement de .médian() est compatible avec .signifier() dans les Pandas. Vous pouvez modifier ce comportement avec le paramètre facultatif skipna.

Mode

le mode échantillon est la valeur de l'ensemble de données la plus fréquente. S'il n'y a pas une seule de ces valeurs, alors l'ensemble est multimodal car il a plusieurs valeurs modales. Par exemple, dans l'ensemble qui contient les points 2, 3, 2, 8 et 12, le numéro 2 est le mode car il se produit deux fois, contrairement aux autres éléments qui ne se produisent qu'une seule fois.

Voici comment vous pouvez obtenir le mode avec Python pur:

>>>

>>> u = [[[[2, 3, 2, 8, 12]
>>> mode_ = max((u.compter(article), article) pour article dans ensemble(u))[[[[1]
>>> mode_
2

Tu utilises u.count () pour obtenir le nombre d'occurrences de chaque élément dans u. L'élément avec le nombre maximal d'occurrences est le mode. Notez que vous n'avez pas besoin d'utiliser ensemble (u). Au lieu de cela, vous pouvez le remplacer par juste u et parcourir toute la liste.

Vous pouvez obtenir le mode avec statistics.mode () et statistics.multimode ():

>>>

>>> mode_ = statistiques.mode(u)
>>> mode_
>>> mode_ = statistiques.multimode(u)
>>> mode_
[2]

Comme vous pouvez le voir, mode() a renvoyé une seule valeur, multimode () a renvoyé la liste qui contient le résultat. Ce n'est cependant pas la seule différence entre les deux fonctions. S'il y a plus d'une valeur modale, alors mode() soulève StatisticsError, tandis que multimode () renvoie la liste avec tous les modes:

>>>

>>> v = [[[[12, 15, 12, 15, 21, 15, 12]
>>> statistiques.mode(v)  # Augmente StatisticsError
>>> statistiques.multimode(v)
[12, 15]

Vous devez porter une attention particulière à ce scénario et être prudent lorsque vous choisissez entre ces deux fonctions.

statistics.mode () et statistics.multimode () manipuler nan valeurs en tant que valeurs régulières et peuvent renvoyer nan comme valeur modale:

>>>

>>> statistiques.mode([[[[2, math.nan, 2])
2
>>> statistiques.multimode([[[[2, math.nan, 2])
[2]
>>> statistiques.mode([[[[2, math.nan, 0, math.nan, 5])
nan
>>> statistiques.multimode([[[[2, math.nan, 0, math.nan, 5])
[nan]

Dans le premier exemple ci-dessus, le nombre 2 se produit deux fois et est la valeur modale. Dans le deuxième exemple, nan est la valeur modale car elle apparaît deux fois, tandis que les autres valeurs n'apparaissent qu'une seule fois.

Vous pouvez également obtenir le mode avec scipy.stats.mode ():

>>>

>>> u, v = np.tableau(u), np.tableau(v)
>>> mode_ = scipy.Statistiques.mode(u)
>>> mode_
ModeResult (mode = array ([2]), count = tableau ([2]))
>>> mode_ = scipy.Statistiques.mode(v)
>>> mode_
ModeResult (mode = array ([12]), count = tableau ([3]))

Cette fonction renvoie l'objet avec la valeur modale et le nombre de fois où il se produit. S'il existe plusieurs valeurs modales dans l'ensemble de données, alors seul le le plus petit la valeur est retournée.

Vous pouvez obtenir le mode et son nombre d'occurrences sous forme de tableaux NumPy avec notation par points:

>>>

>>> mode_.mode
tableau ([12])
>>> mode_.compter
tableau ([3])

Ce code utilise .mode pour retourner le plus petit mode (12) dans le tableau v et .compter pour renvoyer le nombre de fois où cela se produit (3). scipy.stats.mode () est également flexible avec nan valeurs. Il vous permet de définir le comportement souhaité avec le paramètre optionnel nan_policy. Ce paramètre peut prendre les valeurs 'propager', 'élever' (une erreur), ou 'omettre'.

Pandas Séries les objets ont la méthode .mode() qui gère bien les valeurs multimodales et ignore nan valeurs par défaut:

>>>

>>> u, v, w = pd.Séries(u), pd.Séries(v), pd.Séries([[[[2, 2, math.nan])
>>> u.mode()
0 2
dtype: int64
>>> v.mode()
0 12
1 15
dtype: int64
>>> w.mode()
0 2,0
dtype: float64

Comme vous pouvez le voir, .mode() renvoie un nouveau pd.Series qui contient toutes les valeurs modales. Si tu veux .mode() prendre nan valeurs en compte, puis passez simplement l'argument facultatif dropna = Faux.

Mesures de variabilité

Les mesures de tendance centrale ne suffisent pas à décrire les données. Vous aurez également besoin du mesures de variabilité qui quantifient la propagation des points de données. Dans cette section, vous apprendrez à identifier et à calculer les mesures de variabilité suivantes:

  • Variance
  • Déviation standard
  • Asymétrie
  • Percentiles
  • Gammes

Variance

le variance de l'échantillon quantifie la diffusion des données. Il montre numériquement la distance entre les points de données et la moyenne. Vous pouvez exprimer la variance d'échantillon de l'ensemble de données avec éléments mathématiquement comme ² = Σᵢ (ᵢ – moyenne ()) ² / ( – 1), où = 1, 2,…, et moyenne () est la moyenne de l'échantillon de . Si vous voulez comprendre plus profondément pourquoi vous divisez la somme avec – 1 au lieu de , alors vous pouvez approfondir la correction de Bessel.

La figure suivante vous montre pourquoi il est important de prendre en compte la variance lors de la description des jeux de données:

Statistiques Python

Il y a deux jeux de données dans cette figure:

  1. Points verts: Cet ensemble de données présente une variance plus petite ou une différence moyenne plus petite que la moyenne. Il a également une plage plus petite ou une différence plus petite entre le plus grand et le plus petit article.
  2. Points blancs: Cet ensemble de données présente une variance plus grande ou une différence moyenne plus grande que la moyenne. Il a également une plus grande gamme ou une plus grande différence entre le plus grand et le plus petit article.

Notez que ces deux ensembles de données ont la même moyenne et la même médiane, même s'ils semblent différer considérablement. Ni la moyenne ni la médiane ne peuvent décrire cette différence. C’est pourquoi vous avez besoin des mesures de variabilité.

Voici comment vous pouvez calculer la variance de l'échantillon avec du Python pur:

>>>

>>> n = len(X)
>>> signifier_ = somme(X) / n
>>> var_ = somme((article - signifier_)**2 pour article dans X) / (n - 1)
>>> var_
123.19999999999999

Cette approche est suffisante et calcule bien la variance de l'échantillon. Cependant, la solution la plus courte et la plus élégante consiste à appeler la fonction existante statistics.variance ():

>>>

>>> var_ = statistics.variance(X)
>>> var_
123.2

You’ve obtained the same result for the variance as above. variance() can avoid calculating the mean if you provide the mean explicitly as the second argument: statistics.variance(x, mean_).

If you have nan values among your data, then statistics.variance() will return nan:

>>>

>>> statistics.variance(x_with_nan)
nan

This behavior is consistent with mean() and most other functions from the Python statistics bibliothèque.

You can also calculate the sample variance with NumPy. You should use the function np.var() or the corresponding method .var():

>>>

>>> var_ = np.var(y, ddof=1)
>>> var_
123.19999999999999
>>> var_ = y.var(ddof=1)
>>> var_
123.19999999999999

It’s very important to specify the parameter ddof=1. That’s how you set the delta degrees of freedom to 1. This parameter allows the proper calculation of ², with ( − 1) in the denominator instead of .

If you have nan values in the dataset, then np.var() et .var() will return nan:

>>>

>>> np.var(y_with_nan, ddof=1)
nan
>>> y_with_nan.var(ddof=1)
nan

This is consistent with np.mean() et np.average(). If you want to skip nan values, then you should use np.nanvar():

>>>

>>> np.nanvar(y_with_nan, ddof=1)
123.19999999999999

np.nanvar() ignores nan values. It also needs you to specify ddof=1.

pd.Series objects have the method .var() that skips nan values by default:

>>>

>>> z.var(ddof=1)
123.19999999999999
>>> z_with_nan.var(ddof=1)
123.19999999999999

It also has the parameter ddof, but its default value is 1, so you can omit it. If you want a different behavior related to nan values, then use the optional parameter skipna.

You calculate the population variance similarly to the sample variance. However, you have to use in the denominator instead of − 1: Σᵢ(ᵢ − mean())² / . In this case, is the number of items in the entire population. You can get the population variance similar to the sample variance, with the following differences:

  • Replace (n - 1) avec n in the pure Python implementation.
  • Utilisation statistics.pvariance() instead of statistics.variance().
  • Specify the parameter ddof=0 if you use NumPy or Pandas. In NumPy, you can omit ddof because its default value is 0.

Note that you should always be aware of whether you’re working with a sample or the entire population whenever you’re calculating the variance!

Standard Deviation

le sample standard deviation is another measure of data spread. It’s connected to the sample variance, as standard deviation, , is the positive square root of the sample variance. The standard deviation is often more convenient than the variance because it has the same unit as the data points. Once you get the variance, you can calculate the standard deviation with pure Python:

>>>

>>> std_ = var_ ** 0.5
>>> std_
11.099549540409285

Although this solution works, you can also use statistics.stdev():

>>>

>>> std_ = statistics.stdev(X)
>>> std_
11.099549540409287

Of course, the result is the same as before. Like variance(), stdev() doesn’t calculate the mean if you provide it explicitly as the second argument: statistics.stdev(x, mean_).

You can get the standard deviation with NumPy in almost the same way. You can use the function std() and the corresponding method .std() to calculate the standard deviation. If there are nan values in the dataset, then they’ll return nan. To ignore nan values, you should use np.nanstd(). You use std(), .std(), et nanstd() from NumPy as you would use var(), .var(), et nanvar():

>>>

>>> np.std(y, ddof=1)
11.099549540409285
>>> y.std(ddof=1)
11.099549540409285
>>> np.std(y_with_nan, ddof=1)
nan
>>> y_with_nan.std(ddof=1)
nan
>>> np.nanstd(y_with_nan, ddof=1)
11.099549540409285

Don’t forget to set the delta degrees of freedom to 1!

pd.Series objects also have the method .std() that skips nan by default:

>>>

>>> z.std(ddof=1)
11.099549540409285
>>> z_with_nan.std(ddof=1)
11.099549540409285

The parameter ddof defaults to 1, so you can omit it. Again, if you want to treat nan values differently, then apply the parameter skipna.

le population standard deviation refers to the entire population. It’s the positive square root of the population variance. You can calculate it just like the sample standard deviation, with the following differences:

  • Trouver the square root of the population variance in the pure Python implementation.
  • Utilisation statistics.pstdev() instead of statistics.stdev().
  • Specify the parameter ddof=0 if you use NumPy or Pandas. In NumPy, you can omit ddof because its default value is 0.

As you can see, you can determine the standard deviation in Python, NumPy, and Pandas in almost the same way as you determine the variance. You use different but analogous functions and methods with the same arguments.

Skewness

le sample skewness measures the asymmetry of a data sample.

There are several mathematical definitions of skewness. One common expression to calculate the skewness of the dataset with elements is (² / (( − 1)( − 2))) (Σᵢ(ᵢ − mean())³ / (³)). A simpler expression is Σᵢ(ᵢ − mean())³ / (( − 1)( − 2)³), where = 1, 2, …, and mean() is the sample mean of . The skewness defined like this is called the adjusted Fisher-Pearson standardized moment coefficient.

The previous figure showed two datasets that were quite symmetrical. In other words, their points had similar distances from the mean. In contrast, the following image illustrates two asymmetrical sets:

Python Statistics

The first set is represented by the green dots and the second with the white ones. Habituellement, negative skewness values indicate that there’s a dominant tail on the left side, which you can see with the first set. Positive skewness values correspond to a longer or fatter tail on the right side, which you can see in the second set. If the skewness is close to 0 (for example, between −0.5 and 0.5), then the dataset is considered quite symmetrical.

Once you’ve calculated the size of your dataset n, the sample mean mean_, and the standard deviation std_, you can get the sample skewness with pure Python:

>>>

>>> X = [[[[8.0, 1, 2,5, 4, 28.0]
>>> n = len(X)
>>> mean_ = sum(X) / n
>>> var_ = sum((item - mean_)**2 pour item dans X) / (n - 1)
>>> std_ = var_ ** 0.5
>>> skew_ = (sum((item - mean_)**3 pour item dans X)
...          * n / ((n - 1) * (n - 2) * std_**3))
>>> skew_
1.9470432273905929

The skewness is positive, so X has a right-side tail.

You can also calculate the sample skewness with scipy.stats.skew():

>>>

>>> y, y_with_nan = np.array(X), np.array(x_with_nan)
>>> scipy.Statistiques.skew(y, bias=Faux)
1.9470432273905927
>>> scipy.Statistiques.skew(y_with_nan, bias=Faux)
nan

The obtained result is the same as the pure Python implementation. The parameter bias is set to Faux to enable the corrections for statistical bias. The optional parameter nan_policy can take the values 'propagate', 'raise', ou 'omit'. It allows you to control how you’ll handle nan values.

Pandas Series objects have the method .skew() that also returns the skewness of a dataset:

>>>

>>> z, z_with_nan = pd.Series(X), pd.Series(x_with_nan)
>>> z.skew()
1.9470432273905924
>>> z_with_nan.skew()
1.9470432273905924

Like other methods, .skew() ignores nan values by default, because of the default value of the optional parameter skipna.

Percentiles

le sample percentile is the element in the dataset such that % of the elements in the dataset are less than or equal to that value. Also, (100 − )% of the elements are greater than or equal to that value. If there are two such elements in the dataset, then the sample percentile is their arithmetic mean. Each dataset has three quartiles, which are the percentiles that divide the dataset into four parts:

  • The first quartile is the sample 25th percentile. It divides roughly 25% of the smallest items from the rest of the dataset.
  • The second quartile is the sample 50th percentile or the médian. Approximately 25% of the items lie between the first and second quartiles and another 25% between the second and third quartiles.
  • The third quartile is the sample 75th percentile. It divides roughly 25% of the largest items from the rest of the dataset.

Each part has approximately the same number of items. If you want to divide your data into several intervals, then you can use statistics.quantiles():

>>>

>>> X = [[[[-5.0, -1.1, 0,1, 2.0, 8.0, 12.8, 21.0, 25.8, 41.0]
>>> statistics.quantiles(X, n=2)
[8.0]
>>> statistics.quantiles(X, n=4, method='inclusive')
[0.1, 8.0, 21.0]

In this example, 8.0 is the median of X, tandis que 0,1 et 21.0 are the sample 25th and 75th percentiles, respectively. The parameter n defines the number of resulting equal-probability percentiles, and method determines how to calculate them.

You can also use np.percentile() to determine any sample percentile in your dataset. For example, this is how you can find the 5th and 95th percentiles:

>>>

>>> y = np.array(X)
>>> np.percentile(y, 5)
-3.44
>>> np.percentile(y, 95)
34.919999999999995

percentile() takes several arguments. You have to provide the dataset as the first argument and the percentile value as the second. The dataset can be in the form of a NumPy array, list, tuple, or similar data structure. The percentile can be a number between 0 and 100 like in the example above, but it can also be a sequence of numbers:

>>>

>>> np.percentile(y, [[[[25, 50, 75])
array([ 0.1,  8. , 21. ])
>>> np.médian(y)
8.0

This code calculates the 25th, 50th, and 75th percentiles all at once. If the percentile value is a sequence, then percentile() returns a NumPy array with the results. The first statement returns the array of quartiles. The second statement returns the median, so you can confirm it’s equal to the 50th percentile, which is 8.0.

If you want to ignore nan values, then use np.nanpercentile() instead:

>>>

>>> y_with_nan = np.insérer(y, 2, np.nan)
>>> y_with_nan
array([-5. , -1.1,  nan,  0.1,  2. ,  8. , 12.8, 21. , 25.8, 41. ])
>>> np.nanpercentile(y_with_nan, [[[[25, 50, 75])
array([ 0.1,  8. , 21. ])

That’s how you can avoid nan values.

NumPy also offers you very similar functionality in quantile() et nanquantile(). If you use them, then you’ll need to provide the quantile values as the numbers between 0 and 1 instead of percentiles:

>>>

>>> np.quantile(y, 0,05)
-3.44
>>> np.quantile(y, 0.95)
34.919999999999995
>>> np.quantile(y, [[[[0.25, 0.5, 0.75])
array([ 0.1,  8. , 21. ])
>>> np.nanquantile(y_with_nan, [[[[0.25, 0.5, 0.75])
array([ 0.1,  8. , 21. ])

The results are the same as in the previous examples, but here your arguments are between 0 and 1. In other words, you passed 0,05 instead of 5 et 0.95 instead of 95.

pd.Series objects have the method .quantile():

>>>

>>> z, z_with_nan = pd.Series(y), pd.Series(y_with_nan)
>>> z.quantile(0,05)
-3.44
>>> z.quantile(0.95)
34.919999999999995
>>> z.quantile([[[[0.25, 0.5, 0.75])
0.25     0.1
0.50     8.0
0.75    21.0
dtype: float64
>>> z_with_nan.quantile([[[[0.25, 0.5, 0.75])
0.25     0.1
0.50     8.0
0.75    21.0
dtype: float64

.quantile() also needs you to provide the quantile value as the argument. This value can be a number between 0 and 1 or a sequence of numbers. In the first case, .quantile() returns a scalar. In the second case, it returns a new Series holding the results.

Ranges

le range of data is the difference between the maximum and minimum element in the dataset. You can get it with the function np.ptp():

>>>

>>> np.ptp(y)
46.0
>>> np.ptp(z)
46.0
>>> np.ptp(y_with_nan)
nan
>>> np.ptp(z_with_nan)
46.0

This function returns nan if there are nan values in your NumPy array. If you use a Pandas Series object, then it will return a number.

Alternatively, you can use built-in Python, NumPy, or Pandas functions and methods to calculate the maxima and minima of sequences:

Here are some examples of how you would use these routines:

>>>

>>> np.amax(y) - np.amin(y)
46.0
>>> np.nanmax(y_with_nan) - np.nanmin(y_with_nan)
46.0
>>> y.max() - y.min()
46.0
>>> z.max() - z.min()
46.0
>>> z_with_nan.max() - z_with_nan.min()
46.0

That’s how you get the range of data.

le interquartile range is the difference between the first and third quartile. Once you calculate the quartiles, you can take their difference:

>>>

>>> quartiles = np.quantile(y, [[[[0.25, 0.75])
>>> quartiles[[[[1] - quartiles[[[[0]
20.9
>>> quartiles = z.quantile([[[[0.25, 0.75])
>>> quartiles[[[[0.75] - quartiles[[[[0.25]
20.9

Note that you access the values in a Pandas Series object with the labels 0.75 et 0.25.

Summary of Descriptive Statistics

SciPy and Pandas offer useful routines to quickly get descriptive statistics with a single function or method call. You can use scipy.stats.describe() like this:

>>>

>>> result = scipy.Statistiques.describe(y, ddof=1, bias=Faux)
>>> result
DescribeResult(nobs=9, minmax=(-5.0, 41.0), mean=11.622222222222222, variance=228.75194444444446, skewness=0.9249043136685094, kurtosis=0.14770623629658886)

You have to provide the dataset as the first argument. The argument can be a NumPy array, list, tuple, or similar data structure. You can omit ddof=1 since it’s the default and only matters when you’re calculating the variance. You can pass bias=False to force correcting the skewness and kurtosis for statistical bias.

describe() returns an object that holds the following descriptive statistics:

  • nobs: the number of observations or elements in your dataset
  • minmax: the tuple with the minimum and maximum values of your dataset
  • mean: the mean of your dataset
  • variance: the variance of your dataset
  • skewness: the skewness of your dataset
  • kurtosis: the kurtosis of your dataset

You can access particular values with dot notation:

>>>

>>> result.nobs
9
>>> result.minmax[[[[0]  # Min
-5.0
>>> result.minmax[[[[1]  # Max
41.0
>>> result.mean
11.622222222222222
>>> result.variance
228.75194444444446
>>> result.skewness
0.9249043136685094
>>> result.kurtosis
0.14770623629658886

With SciPy, you’re just one function call away from a descriptive statistics summary for your dataset.

Pandas has similar, if not better, functionality. Series objects have the method .describe():

>>>

>>> result = z.describe()
>>> result
count     9.000000
mean     11.622222
std      15.124548
min      -5.000000
25%       0.100000
50%       8.000000
75%      21.000000
max      41.000000
dtype: float64

It returns a new Series that holds the following:

  • count: the number of elements in your dataset
  • mean: the mean of your dataset
  • std: the standard deviation of your dataset
  • min et max: the minimum and maximum values of your dataset
  • 25%, 50%, et 75%: the quartiles of your dataset

If you want the resulting Series object to contain other percentiles, then you should specify the value of the optional parameter percentiles. You can access each item of result with its label:

>>>

>>> result[[[['mean']
11.622222222222222
>>> result[[[['std']
15.12454774346805
>>> result[[[['min']
-5.0
>>> result[[[['max']
41.0
>>> result[[[['25%']
0,1
>>> result[[[['50%']
8.0
>>> result[[[['75%']
21.0

That’s how you can get descriptive statistics of a Series object with a single method call using Pandas.

Measures of Correlation Between Pairs of Data

You’ll often need to examine the relationship between the corresponding elements of two variables in a dataset. Say there are two variables, and , with an equal number of elements, . Let ₁ from correspond to ₁ from , ₂ from to ₂ from , and so on. You can then say that there are pairs of corresponding elements: (₁, ₁), (₂, ₂), and so on.

You’ll see the following measures of correlation between pairs of data:

  • Positive correlation exists when larger values of correspond to larger values of and vice versa.
  • Negative correlation exists when larger values of correspond to smaller values of and vice versa.
  • Weak or no correlation exists if there is no such apparent relationship.

The following figure shows examples of negative, weak, and positive correlation:

Python Statistics

The plot on the left with the red dots shows negative correlation. The plot in the middle with the green dots shows weak correlation. Finally, the plot on the right with the blue dots shows positive correlation.

The two statistics that measure the correlation between datasets are covariance and the correlation coefficient. Let’s define some data to work with these measures. You’ll create two Python lists and use them to get corresponding NumPy arrays and Pandas Series:

>>>

>>> X = liste(range(-dix, 11))
>>> y = [[[[0, 2, 2, 2, 2, 3, 3, 6, 7, 4, 7, 6, 6, 9, 4, 5, 5, dix, 11, 12, 14]
>>> x_, y_ = np.array(X), np.array(y)
>>> x__, y__ = pd.Series(x_), pd.Series(y_)

Now that you have the two variables, you can start exploring the relationship between them.

Covariance

le sample covariance is a measure that quantifies the strength and direction of a relationship between a pair of variables:

  • If the correlation is positive, then the covariance is positive, as well. A stronger relationship corresponds to a higher value of the covariance.
  • If the correlation is negative, then the covariance is negative, as well. A stronger relationship corresponds to a lower (or higher absolute) value of the covariance.
  • If the correlation is weak, then the covariance is close to zero.

The covariance of the variables and is mathematically defined as ˣʸ = Σᵢ (ᵢ − mean()) (ᵢ − mean()) / ( − 1), where = 1, 2, …, , mean() is the sample mean of , and mean() is the sample mean of . It follows that the covariance of two identical variables is actually the variance: ˣˣ = Σᵢ(ᵢ − mean())² / ( − 1) = (ˣ)² and ʸʸ = Σᵢ(ᵢ − mean())² / ( − 1) = (ʸ)².

This is how you can calculate the covariance in pure Python:

>>>

>>> n = len(X)
>>> mean_x, mean_y = sum(X) / n, sum(y) / n
>>> cov_xy = (sum((X[[[[k] - mean_x) * (y[[[[k] - mean_y) pour k dans range(n))
...           / (n - 1))
>>> cov_xy
19.95

First, you have to find the mean of X et y. Then, you apply the mathematical formula for the covariance.

NumPy has the function cov() that returns the covariance matrix:

>>>

>>> cov_matrix = np.cov(x_, y_)
>>> cov_matrix
array([[38.5       , 19.95      ],
       [19.95      , 13.91428571]])

Notez que cov() has the optional parameters bias, which defaults to Faux, et ddof, which defaults to Aucun. Their default values are suitable for getting the sample covariance matrix. The upper-left element of the covariance matrix is the covariance of X et X, or the variance of X. Similarly, the lower-right element is the covariance of y et y, or the variance of y. You can check to see that this is true:

>>>

>>> x_.var(ddof=1)
38,5
>>> y_.var(ddof=1)
13.914285714285711

As you can see, the variances of X et y are equal to cov_matrix[0, 0] et cov_matrix[1, 1], respectively.

The other two elements of the covariance matrix are equal and represent the actual covariance between X et y:

>>>

>>> cov_xy = cov_matrix[[[[0, 1]
>>> cov_xy
19.95
>>> cov_xy = cov_matrix[[[[1, 0]
>>> cov_xy
19.95

You’ve obtained the same value of the covariance with np.cov() as with pure Python.

Pandas Series have the method .cov() that you can use to calculate the covariance:

>>>

>>> cov_xy = x__.cov(y__)
>>> cov_xy
19.95
>>> cov_xy = y__.cov(x__)
>>> cov_xy
19.95

Here, you call .cov() on one Series object and pass the other object as the first argument.

Correlation Coefficient

le correlation coefficient, ou Pearson product-moment correlation coefficient, is denoted by the symbol . The coefficient is another measure of the correlation between data. You can think of it as a standardized covariance. Here are some important facts about it:

  • The value > 0 indicates positive correlation.
  • The value < 0 indicates negative correlation.
  • The value r = 1 is the maximum possible value of . It corresponds to a perfect positive linear relationship between variables.
  • The value r = −1 is the minimum possible value of . It corresponds to a perfect negative linear relationship between variables.
  • The value r ≈ 0, or when is around zero, means that the correlation between variables is weak.

The mathematical formula for the correlation coefficient is = ˣʸ / (ˣʸ) where ˣ and ʸ are the standard deviations of and respectively. If you have the means (mean_x et mean_y) and standard deviations (std_x, std_y) for the datasets X et y, as well as their covariance cov_xy, then you can calculate the correlation coefficient with pure Python:

>>>

>>> var_x = sum((item - mean_x)**2 pour item dans X) / (n - 1)
>>> var_y = sum((item - mean_y)**2 pour item dans y) / (n - 1)
>>> std_x, std_y = var_x ** 0.5, var_y ** 0.5
>>> r = cov_xy / (std_x * std_y)
>>> r
0.861950005631606

You’ve got the variable r that represents the correlation coefficient.

scipy.stats has the routine pearsonr() that calculates the correlation coefficient and the -value:

>>>

>>> r, p = scipy.Statistiques.pearsonr(x_, y_)
>>> r
0.861950005631606
>>> p
5.122760847201171e-07

pearsonr() returns a tuple with two numbers. The first one is and the second is the -value.

Similar to the case of the covariance matrix, you can apply np.corrcoef() avec x_ et y_ as the arguments and get the correlation coefficient matrix:

>>>

>>> corr_matrix = np.corrcoef(x_, y_)
>>> corr_matrix
array([[1.        , 0.86195001],
       [0.86195001, 1.        ]])

The upper-left element is the correlation coefficient between x_ et x_. The lower-right element is the correlation coefficient between y_ et y_. Their values are equal to 1.0. The other two elements are equal and represent the actual correlation coefficient between x_ et y_:

>>>

>>> r = corr_matrix[[[[0, 1]
>>> r
0.8619500056316061
>>> r = corr_matrix[[[[1, 0]
>>> r
0.861950005631606

Of course, the result is the same as with pure Python and pearsonr().

You can get the correlation coefficient with scipy.stats.linregress():

>>>

>>> scipy.Statistiques.linregress(x_, y_)
LinregressResult(slope=0.5181818181818181, intercept=5.714285714285714, rvalue=0.861950005631606, pvalue=5.122760847201164e-07, stderr=0.06992387660074979)

linregress() takes x_ et y_, performs linear regression, and returns the results. slope et intercept define the equation of the regression line, while rvalue is the correlation coefficient. To access particular values from the result of linregress(), including the correlation coefficient, use dot notation:

>>>

>>> result = scipy.Statistiques.linregress(x_, y_)
>>> r = result.rvalue
>>> r
0.861950005631606

That’s how you can perform linear regression and obtain the correlation coefficient.

Pandas Series have the method .corr() for calculating the correlation coefficient:

>>>

>>> r = x__.corr(y__)
>>> r
0.8619500056316061
>>> r = y__.corr(x__)
>>> r
0.861950005631606

You should call .corr() on one Series object and pass the other object as the first argument.

Working With 2D Data

Statisticians often work with 2D data. Here are some examples of 2D data formats:

NumPy and SciPy provide a comprehensive means to work with 2D data. Pandas has the class DataFrame specifically to handle 2D labeled data.

Axes

Start by creating a 2D NumPy array:

>>>

>>> une = np.array([[[[[[[[1, 1, 1],
...               [[[[2, 3, 1],
...               [[[[4, 9, 2],
...               [[[[8, 27, 4],
...               [[[[16, 1, 1]])
>>> une
array([[ 1,  1,  1],
       [ 2,  3,  1],
       [ 4,  9,  2],
       [ 8, 27,  4],
       [16,  1,  1]])

Now you have a 2D dataset, which you’ll use in this section. You can apply Python statistics functions and methods to it just as you would to 1D data:

>>>

>>> np.mean(une)
5.4
>>> une.mean()
5.4
>>> np.médian(une)
2.0
>>> une.var(ddof=1)
53.40000000000001

As you can see, you get statistics (like the mean, median, or variance) across all data in the array une. Sometimes, this behavior is what you want, but in some cases, you’ll want these quantities calculated for each row or column of your 2D array.

The functions and methods you’ve used so far have one optional parameter called axis, which is essential for handling 2D data. axis can take on any of the following values:

  • axis=None says to calculate the statistics across all data in the array. The examples above work like this. This behavior is often the default in NumPy.
  • axis=0 says to calculate the statistics across all rows, that is, for each column of the array. This behavior is often the default for SciPy statistical functions.
  • axis=1 says to calculate the statistics across all columns, that is, for each row of the array.

Let’s see axis=0 in action with np.mean():

>>>

>>> np.mean(une, axis=0)
array([6.2, 8.2, 1.8])
>>> une.mean(axis=0)
array([6.2, 8.2, 1.8])

The two statements above return new NumPy arrays with the mean for each column of une. In this example, the mean of the first column is 6.2. The second column has the mean 8.2, while the third has 1.8.

If you provide axis=1 à mean(), then you’ll get the results for each row:

>>>

>>> np.mean(une, axis=1)
array([ 1.,  2.,  5., 13.,  6.])
>>> une.mean(axis=1)
array([ 1.,  2.,  5., 13.,  6.])

As you can see, the first row of une has the mean 1.0, the second 2.0, etc.

The parameter axis works the same way with other NumPy functions and methods:

>>>

>>> np.médian(une, axis=0)
array([4., 3., 1.])
>>> np.médian(une, axis=1)
array([1., 2., 4., 8., 1.])
>>> une.var(axis=0, ddof=1)
array([ 37.2, 121.2,   1.7])
>>> une.var(axis=1, ddof=1)
array([  0.,   1.,  13., 151.,  75.])

You’ve got the medians and sample variations for all columns (axis=0) and rows (axis=1) of the array une.

This is very similar when you work with SciPy statistics functions. But remember that in this case, the default value for axis est 0:

>>>

>>> scipy.Statistiques.gmean(une)  # Default: axis=0
array([4.        , 3.73719282, 1.51571657])
>>> scipy.Statistiques.gmean(une, axis=0)
array([4.        , 3.73719282, 1.51571657])

If you omit axis or provide axis=0, then you’ll get the result across all rows, that is, for each column. For example, the first column of une has a geometric mean of 4,0, etc.

If you specify axis=1, then you’ll get the calculations across all columns, that is for each row:

>>>

>>> scipy.Statistiques.gmean(une, axis=1)
array([1.        , 1.81712059, 4.16016765, 9.52440631, 2.5198421 ])

In this example, the geometric mean of the first row of une est 1.0. For the second row, it’s approximately 1.82, etc.

If you want statistics for the entire dataset, then you have to provide axis=None:

>>>

>>> scipy.Statistiques.gmean(une, axis=Aucun)
2.829705017016332

The geometric mean of all the items in the array une is approximately 2.83.

You can get a Python statistics summary with a single function call for 2D data with scipy.stats.describe(). It works similar to 1D arrays, but you have to be careful with the parameter axis:

>>>

>>> scipy.Statistiques.describe(une, axis=Aucun, ddof=1, bias=Faux)
DescribeResult(nobs=15, minmax=(1, 27), mean=5.4, variance=53.40000000000001, skewness=2.264965290423389, kurtosis=5.212690982795767)
>>> scipy.Statistiques.describe(une, ddof=1, bias=Faux)  # Default: axis=0
DescribeResult(nobs=5, minmax=(array([1, 1, 1]), array([16, 27,  4])), mean=array([6.2, 8.2, 1.8]), variance=array([ 37.2, 121.2,   1.7]), skewness=array([1.32531471, 1.79809454, 1.71439233]), kurtosis=array([1.30376344, 3.14969121, 2.66435986]))
>>> scipy.Statistiques.describe(une, axis=1, ddof=1, bias=Faux)
DescribeResult(nobs=3, minmax=(array([1, 1, 2, 4, 1]), array([ 1,  3,  9, 27, 16])), mean=array([ 1.,  2.,  5., 13.,  6.]), variance=array([  0.,   1.,  13., 151.,  75.]), skewness=array([0.        , 0.        , 1.15206964, 1.52787436, 1.73205081]), kurtosis=array([-3. , -1.5, -1.5, -1.5, -1.5]))

When you provide axis=None, you get the summary across all data. Most results are scalars. If you set axis=0 or omit it, then the return value is the summary for each column. So, most results are the arrays with the same number of items as the number of columns. If you set axis=1, then describe() returns the summary for all rows.

You can get a particular value from the summary with dot notation:

>>>

>>> result = scipy.Statistiques.describe(une, axis=1, ddof=1, bias=Faux)
>>> result.mean
array([ 1.,  2.,  5., 13.,  6.])

That’s how you can see a statistics summary for a 2D array with a single function call.

DataFrames

The class DataFrame is one of the fundamental Pandas data types. It’s very comfortable to work with because it has labels for rows and columns. Use the array une and create a DataFrame:

>>>

>>> row_names = [[[['first', 'second', 'third', 'fourth', 'fifth']
>>> col_names = [[[['A', 'B', 'C']
>>> df = pd.DataFrame(une, index=row_names, columns=col_names)
>>> df
                                    A   B  C
first    1   1  1
second   2   3  1
third    4   9  2
fourth   8  27  4
fifth   16   1  1

In practice, the names of the columns matter and should be descriptive. The names of the rows are sometimes specified automatically as 0, 1, etc. You can specify them explicitly with the parameter index, though you’re free to omit index if you like.

DataFrame methods are very similar to Series methods, though the behavior is different. If you call Python statistics methods without arguments, then the DataFrame will return the results for each column:

>>>

>>> df.mean()
A    6.2
B    8.2
C    1.8
dtype: float64
>>> df.var()
A     37.2
B    121.2
C      1.7
dtype: float64

What you get is a new Series that holds the results. In this case, the Series holds the mean and variance for each column. If you want the results for each row, then just specify the parameter axis=1:

>>>

>>> df.mean(axis=1)
first      1.0
second     2.0
third      5.0
fourth    13.0
fifth      6.0
dtype: float64
>>> df.var(axis=1)
first       0.0
second      1.0
third      13.0
fourth    151.0
fifth      75.0
dtype: float64

The result is a Series with the desired quantity for each row. The labels 'first', 'second', and so on refer to the different rows.

You can isolate each column of a DataFrame comme ça:

>>>

>>> df[[[['A']
first      1
second     2
third      4
fourth     8
fifth     16
Name: A, dtype: int64

Now, you have the column 'A' in the form of a Series object and you can apply the appropriate methods:

>>>

>>> df[[[['A'].mean()
6.2
>>> df[[[['A'].var()
37.20000000000001

That’s how you can obtain the statistics for a single column.

Sometimes, you might want to use a DataFrame as a NumPy array and apply some function to it. It’s possible to get all data from a DataFrame avec .values ou .to_numpy():

>>>

>>> df.valeurs
array([[ 1,  1,  1],
       [ 2,  3,  1],
       [ 4,  9,  2],
       [ 8, 27,  4],
       [16,  1,  1]])
>>> df.to_numpy()
array([[ 1,  1,  1],
       [ 2,  3,  1],
       [ 4,  9,  2],
       [ 8, 27,  4],
       [16,  1,  1]])

df.values et df.to_numpy() give you a NumPy array with all items from the DataFrame without row and column labels. Notez que df.to_numpy() is more flexible because you can specify the data type of items and whether you want to use the existing data or copy it.

Like Series, DataFrame objects have the method .describe() that returns another DataFrame with the statistics summary for all columns:

>>>

>>> df.describe()
                                                        A          B        C
count   5.00000   5.000000  5.00000
mean    6.20000   8.200000  1.80000
std     6.09918  11.009087  1.30384
min     1.00000   1.000000  1.00000
25%     2.00000   1.000000  1.00000
50%     4.00000   3.000000  1.00000
75%     8.00000   9.000000  2.00000
max    16.00000  27.000000  4.00000

The summary contains the following results:

  • count: the number of items in each column
  • mean: the mean of each column
  • std: the standard deviation
  • min et max: the minimum and maximum values
  • 25%, 50%, et 75%: the percentiles

If you want the resulting DataFrame object to contain other percentiles, then you should specify the value of the optional parameter percentiles.

You can access each item of the summary like this:

>>>

>>> df.describe().à[[[['mean', 'A']
6.2
>>> df.describe().à[[[['50%', 'B']
3.0

That’s how you can get descriptive Python statistics in one Series object with a single Pandas method call.

Visualizing Data

In addition to calculating the numerical quantities like mean, median, or variance, you can use visual methods to present, describe, and summarize data. In this section, you’ll learn how to present your data visually using the following graphs:

  • Box plots
  • Histograms
  • Pie charts
  • Bar charts
  • X-Y plots
  • Heatmaps

matplotlib.pyplot is a very convenient and widely-used library, though it’s not the only Python library available for this purpose. You can import it like this:

>>>

>>> import matplotlib.pyplot comme plt
>>> plt.style.utilisation('ggplot')

Now, you have matplotlib.pyplot imported and ready for use. The second statement sets the style for your plots by choosing colors, line widths, and other stylistic elements. You’re free to omit these if you’re satisfied with the default style settings.

You’ll use pseudo-random numbers to get data to work with. You don’t need knowledge on random numbers to be able to understand this section. You just need some arbitrary numbers, and pseudo-random generators are a convenient tool to get them. The module np.random generates arrays of pseudo-random numbers:

NumPy 1.17 introduced another module for pseudo-random number generation. To learn more about it, check the official documentation.

Box Plots

le box plot is an excellent tool to visually represent descriptive statistics of a given dataset. It can show the range, interquartile range, median, mode, outliers, and all quartiles. First, create some data to represent with a box plot:

>>>

>>> np.random.seed(seed=0)
>>> X = np.random.randn(1000)
>>> y = np.random.randn(100)
>>> z = np.random.randn(dix)

The first statement sets the seed of the NumPy random number generator with seed(), so you can get the same results each time you run the code. You don’t have to set the seed, but if you don’t specify this value, then you’ll get different results each time.

The other statements generate three NumPy arrays with normally distributed pseudo-random numbers. X refers to the array with 1000 items, y has 100, and z contains 10 items. Now that you have the data to work with, you can apply .boxplot() to get the box plot:

fig, ax = plt.subplots()
ax.boxplot((X, y, z), vert=Faux, showmeans=True, meanline=True,
           labels=('x', 'y', 'z'), patch_artist=True,
           medianprops='linewidth': 2, 'color': 'purple',
           meanprops='linewidth': 2, 'color': 'red')
plt.spectacle()

The parameters of .boxplot() define the following:

  • X is your data.
  • vert sets the plot orientation to horizontal when Faux. The default orientation is vertical.
  • showmeans shows the mean of your data when True.
  • meanline represents the mean as a line when True. The default representation is a point.
  • labels: the labels of your data.
  • patch_artist determines how to draw the graph.
  • medianprops denotes the properties of the line representing the median.
  • meanprops indicates the properties of the line or dot representing the mean.

There are other parameters, but their analysis is beyond the scope of this tutorial.

The code above produces an image like this:

Python Statistics

You can see three box plots. Each of them corresponds to a single dataset (X, y, ou z) and show the following:

  • The mean is the red dashed line.
  • The median is the purple line.
  • The first quartile is the left edge of the blue rectangle.
  • The third quartile is the right edge of the blue rectangle.
  • The interquartile range is the length of the blue rectangle.
  • The range contains everything from left to right.
  • The outliers are the dots to the left and right.

A box plot can show so much information in a single figure!

Histograms

Histograms are particularly useful when there are a large number of unique values in a dataset. The histogram divides the values from a sorted dataset into intervals, also called bins. Often, all bins are of equal width, though this doesn’t have to be the case. The values of the lower and upper bounds of a bin are called the bin edges.

le frequency is a single value that corresponds to each bin. It’s the number of elements of the dataset with the values between the edges of the bin. By convention, all bins but the rightmost one are half-open. They include the values equal to the lower bounds, but exclude the values equal to the upper bounds. The rightmost bin is closed because it includes both bounds. If you divide a dataset with the bin edges 0, 5, 10, and 15, then there are three bins:

  1. The first and leftmost bin contains the values greater than or equal to 0 and less than 5.
  2. The second bin contains the values greater than or equal to 5 and less than 10.
  3. The third and rightmost bin contains the values greater than or equal to 10 and less than or equal to 15.

The function np.histogram() is a convenient way to get data for histograms:

>>>

>>> hist, bin_edges = np.histogram(X, bins=dix)
>>> hist
array([  9,  20,  70, 146, 217, 239, 160,  86,  38,  15])
>>> bin_edges
array([-304614305-246559324-188504342-13044936-072394379[-304614305-246559324-188504342-13044936-072394379[-304614305-246559324-188504342-13044936-072394379[-304614305-246559324-188504342-13044936-072394379
                            -0.14339397,  0.43715585,  1.01770566,  1.59825548,  2.1788053 ,
                                2.75935511])

It takes the array with your data and the number (or edges) of bins and returns two NumPy arrays:

  1. hist contains the frequency or the number of items corresponding to each bin.
  2. bin_edges contains the edges or bounds of the bin.

Quoi histogram() calculates, .hist() can show graphically:

fig, ax = plt.subplots()
ax.hist(X, bin_edges, cumulative=Faux)
ax.set_xlabel('x')
ax.set_ylabel('Frequency')
plt.spectacle()

The first argument of .hist() is the sequence with your data. The second argument defines the edges of the bins. The third disables the option to create a histogram with cumulative values. The code above produces a figure like this:

Python Statistics

You can see the bin edges on the horizontal axis and the frequencies on the vertical axis.

It’s possible to get the histogram with the cumulative numbers of items if you provide the argument cumulative=True à .hist():

fig, ax = plt.subplots()
ax.hist(X, bin_edges, cumulative=True)
ax.set_xlabel('x')
ax.set_ylabel('Frequency')
plt.spectacle()

This code yields the following figure:

Python Statistics

It shows the histogram with the cumulative values. The frequency of the first and leftmost bin is the number of items in this bin. The frequency of the second bin is the sum of the numbers of items in the first and second bins. The other bins follow this same pattern. Finally, the frequency of the last and rightmost bin is the total number of items in the dataset (in this case, 1000). You can also directly draw a histogram with pd.Series.hist() using matplotlib in the background.

Pie Charts

Pie charts represent data with a small number of labels and given relative frequencies. They work well even with the labels that can’t be ordered (like nominal data). A pie chart is a circle divided into multiple slices. Each slice corresponds to a single distinct label from the dataset and has an area proportional to the relative frequency associated with that label.

Let’s define data associated to three labels:

>>>

>>> X, y, z = 128, 256, 1024

Now, create a pie chart with .pie():

fig, ax = plt.subplots()
ax.pie((X, y, z), labels=('x', 'y', 'z'), autopct="%1.1f%%")
plt.spectacle()

The first argument of .pie() is your data, and the second is the sequence of the corresponding labels. autopct defines the format of the relative frequencies shown on the figure. You’ll get a figure that looks like this:

Python Statistics

The pie chart shows X as the smallest part of the circle, y as the next largest, and then z as the largest part. The percentages denote the relative size of each value compared to their sum.

Bar Charts

Bar charts also illustrate data that correspond to given labels or discrete numeric values. They can show the pairs of data from two datasets. Items of one set are the labels, while the corresponding items of the other are their frequencies. Optionally, they can show the errors related to the frequencies, as well.

The bar chart shows parallel rectangles called bars. Each bar corresponds to a single label and has a height proportional to the frequency or relative frequency of its label. Let’s generate three datasets, each with 21 items:

>>>

>>> X = np.arange(21)
>>> y = np.random.randint(21, Taille=21)
>>> err = np.random.randn(21)

You use np.arange() to get X, or the array of consecutive integers from 0 à 20. You’ll use this to represent the labels. y is an array of uniformly distributed random integers, also between 0 et 20. This array will represent the frequencies. err contains normally distributed floating-point numbers, which are the errors. These values are optional.

You can create a bar chart with .bar() if you want vertical bars or .barh() if you’d like horizontal bars:

fig, ax = plt.subplots())
ax.bar(X, y, yerr=err)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.spectacle()

This code should produce the following figure:

Python Statistics

The heights of the red bars correspond to the frequencies y, while the lengths of the black lines show the errors err. If you don’t want to include the errors, then omit the parameter yerr de .bar().

X-Y Plots

le x-y plot ou scatter plot represents the pairs of data from two datasets. The horizontal x-axis shows the values from the set X, while the vertical y-axis shows the corresponding values from the set y. You can optionally include the regression line and the correlation coefficient. Let’s generate two datasets and perform linear regression with scipy.stats.linregress():

>>>

>>> X = np.arange(21)
>>> y = 5 + 2 * X + 2 * np.random.randn(21)
>>> slope, intercept, r, *__ = scipy.Statistiques.linregress(X, y)
>>> ligne = F'Regression line: y=intercept:.2f+slope:.2fx, r=r:.2f"

The dataset X is again the array with the integers from 0 to 20. y is calculated as a linear function of X distorted with some random noise.

linregress returns several values. You’ll need the slope et intercept of the regression line, as well as the correlation coefficient r. Then you can apply .plot() to get the x-y plot:

fig, ax = plt.subplots()
ax.plot(X, y, linewidth=0, marker='s', label='Data points')
ax.plot(X, intercept + slope * X, label=ligne)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.legend(facecolor='white')
plt.spectacle()

The result of the code above is this figure:

Python Statistics

You can see the data points (x-y pairs) as red squares, as well as the blue regression line.

Heatmaps

UNE heatmap can be used to visually show a matrix. The colors represent the numbers or elements of the matrix. Heatmaps are particularly useful for illustrating the covariance and correlation matrices. You can create the heatmap for a covariance matrix with .imshow():

matrix = np.cov(X, y).round(decimals=2)
fig, ax = plt.subplots()
ax.imshow(matrix)
ax.grid(Faux)
ax.xaxis.set(ticks=(0, 1), ticklabels=('x', 'y'))
ax.yaxis.set(ticks=(0, 1), ticklabels=('x', 'y'))
ax.set_ylim(1.5, -0.5)
pour je dans range(2):
    pour j dans range(2):
        ax.texte(j, je, matrix[[[[je, j], ha='center', va='center', Couleur='w')
plt.spectacle()

Here, the heatmap contains the labels 'x' et 'y' as well as the numbers from the covariance matrix. You’ll get a figure like this:

Python Statistics

The yellow field represents the largest element from the matrix 130.34, while the purple one corresponds to the smallest element 38,5. The blue squares in between are associated with the value 69.9.

You can obtain the heatmap for the correlation coefficient matrix following the same logic:

matrix = np.corrcoef(X, y).round(decimals=2)
fig, ax = plt.subplots()
ax.imshow(matrix)
ax.grid(Faux)
ax.xaxis.set(ticks=(0, 1), ticklabels=('x', 'y'))
ax.yaxis.set(ticks=(0, 1), ticklabels=('x', 'y'))
ax.set_ylim(1.5, -0.5)
pour je dans range(2):
    pour j dans range(2):
        ax.texte(j, je, matrix[[[[je, j], ha='center', va='center', Couleur='w')
plt.spectacle()

The result is the figure below:

Python Statistics

The yellow color represents the value 1.0, and the purple color shows 0.99.

Conclusion

You now know the quantities that describe and summarize datasets and how to calculate them in Python. It’s possible to get descriptive statistics with pure Python code, but that’s rarely necessary. Usually, you’ll use some of the libraries created especially for this purpose:

  • Use Python’s statistics for the most important Python statistics functions.
  • Use NumPy to handle arrays efficiently.
  • Use SciPy for additional Python statistics routines for NumPy arrays.
  • Use Pandas to work with labeled datasets.
  • Use Matplotlib to visualize data with plots, charts, and histograms.

In the era of big data and artificial intelligence, you must know how to calculate descriptive statistics measures. Now you’re ready to dive deeper into the world of data science and machine learning! If you have questions or comments, then please put them in the comments section below.