Articles

Explication de l’écart-type Numpy

by admin

Ce tutoriel explique comment utiliser la fonction d’écart-type Numpy (AKA, np.MST).

À un niveau élevé, la fonction d’écart type Numpy est simple. Il calcule l’écart type des valeurs dans un tableau Numpy.

Mais les détails du fonctionnement exact de la fonction sont un peu complexes et nécessitent des explications.

Ceci étant dit, ce tutoriel expliquera comment utiliser la fonction d’écart-type Numpy.

Il expliquera la syntaxe de np.std(), et vous montre des exemples clairs, étape par étape, du fonctionnement de la fonction.

Le tutoriel est organisé en sections. Vous pouvez cliquer sur l’un des liens suivants, qui vous mènera à la section appropriée.

Table des matières:

  • Un examen très rapide de Numpy
  • Introduction à l’écart-type Numpy
  • La syntaxe de np.std
  • Exemples d’écart-type Numpy
  • FAQ sur l’écart-type Numpy

Cela dit, si vous êtes relativement nouveau sur Numpy, vous voudrez peut-être lire tout le tutoriel.

Un examen rapide de Numpy

Commençons par un examen rapide de Numpy.

Qu’est-ce que Numpy ?

Numpy est une boîte à outils pour travailler avec des données numériques

Pour faire simple, Numpy est une boîte à outils pour travailler avec des données numériques.

Tout d’abord, Numpy dispose d’un ensemble d’outils pour créer une structure de données appelée tableau Numpy.

Vous pouvez considérer un tableau Numpy comme une grille de lignes et de colonnes de nombres. Les tableaux Numpy peuvent être à 1 dimension, à 2 dimensions ou même à n dimensions.

Un tableau 2D ressemble à ceci:

Un exemple d'un tableau NumPy à 2 dimensions avec les nombres 0 à 7.

Par souci de simplicité, dans ce tutoriel, nous allons nous en tenir à des tableaux à 1 ou 2 dimensions.

Il existe une variété de façons de créer différents types de tableaux avec différents types de nombres. Quelques autres outils pour créer des tableaux Numpy incluent l’arrangement numpy, les zéros numpy, les numpy, les tuiles numpy et d’autres méthodes.

Quelle que soit la façon dont vous créez votre tableau Numpy, à un niveau élevé, ce sont simplement des tableaux de nombres.

Numpy fournit des outils pour manipuler des tableaux Numpy

Numpy fournit non seulement des outils pour créer des tableaux Numpy, Numpy fournit également des outils pour travailler avec des tableaux Numpy.

Certains des outils Numpy les plus importants sont les fonctions Numpy pour effectuer des calculs.

Il existe tout un ensemble de fonctions Numpy pour faire des choses comme:

  • calcul de la somme d’un tableau Numpy
  • calcul du maximum
  • calcul de l’exponentielle des nombres dans un tableau
  • calcul de la valeur x à une certaine puissance, pour chaque valeur dans un tableau Numpy

and et une variété d’autres calculs.

L’écart-type Numpy ressemble essentiellement à ces autres outils Numpy. Il est simplement utilisé pour effectuer un calcul (l’écart type) d’un groupe de nombres dans un tableau Numpy.

Une introduction rapide à l’écart-type Numpy

À un niveau très élevé, l’écart-type est une mesure de la propagation d’un ensemble de données. En particulier, il s’agit d’une mesure de la distance entre les points de données et la moyenne des données.

Passons brièvement en revue le calcul de base.

L’écart-type est calculé comme la racine carrée de la variance.

Donc, si nous avons un ensemble de données avec Nnombres, la variance sera:

\begin{equation*}\frac{1}{N}\displaystyle\sum_{i=1}^N(x_i-\overline{x})^2\end{equation*}

Et l’écart-type sera simplement la racine carrée de la variance:

/p>

\begin{equation*}\sqrt{\frac{1}{N}\displaystyle\sum_{i=1}^N(x_i-\overline{x}) ^2}\end{equation*}

Où:

x_i= les valeurs individuelles de l’ensemble de données
N = le nombre de valeurs de l’ensemble de données
\overline{x} div>=la moyenne des valeurs x_i

La plupart du temps, le calcul de l’écart-type à la main est un peu difficile, car vous devez calculer la moyenne, les écarts de chaque point de données par rapport à la moyenne, puis le carré des écarts, etc. Franchement, c’est un peu fastidieux.

Cependant, si vous travaillez en Python, vous pouvez utiliser la fonction d’écart-type Numpy pour effectuer le calcul à votre place.

Une note rapide si vous débutez dans les statistiques

Car cet article de blog concerne l’utilisation du numpy.fonction std(), je ne veux pas trop approfondir les mauvaises herbes sur la façon dont le calcul est effectué à la main. Ce tutoriel est vraiment sur la façon dont nous utilisons la fonction. Donc, si vous avez besoin d’un examen rapide de ce qu’est l’écart-type, vous pouvez regarder cette vidéo.

Ok. Après avoir rapidement examiné ce qu’est l’écart-type, examinons la syntaxe de np.MST.

La syntaxe de np.std

La syntaxe de la fonction d’écart type Numpy est assez simple.

Je vais l’expliquer en une seconde, mais d’abord, je veux vous dire une petite note sur la syntaxe Numpy.

Remarque rapide: la syntaxe exacte dépend de la façon dont vous importez Numpy

En règle générale, lorsque nous écrivons la syntaxe Numpy, nous utilisons l’alias « np ». C’est la convention commune de la plupart des scientifiques des données.

Pour définir cet alias, vous devez importer Numpy comme ceci:

import numpy as np

Si nous importons Numpy avec cet alias, nous pouvons appeler la fonction d’écart-type Numpy comme np.std().

Ok, cela étant dit, regardons de plus près la syntaxe.

np.syntaxe std

À un niveau élevé, la syntaxe pour np.std ressemble à ceci:

Une image qui explique la syntaxe de l'écart-type Numpy.

Comme je l’ai mentionné précédemment, en supposant que nous ayons importé Numpy avec l’alias « np« nous appelons la fonction avec la syntaxe np.std().

Ensuite, à l’intérieur de la parenthèse, plusieurs paramètres vous permettent de contrôler exactement le fonctionnement de la fonction.

Examinons ces paramètres.

Les paramètres de numpy.std

Il y a quelques paramètres importants à connaître:

  • a
  • axis
  • dtype
  • ddof
  • keepdims
  • out

Examinons chacun d’eux.

a(obligatoire)

Le paramètre a spécifie le tableau de valeurs sur lequel vous souhaitez calculer l’écart-type.

Dit différemment, cela vous permet de spécifier le tableau d’entrée de la fonction.

Les entrées appropriées incluent des tableaux Numpy, mais aussi des objets « de type tableau » tels que des listes Python.

Il est important de fournir une entrée à ce paramètre. Une entrée est requise.

Cela dit, le paramètre lui-même peut être implicite ou explicite. Ce que je veux dire par là, c’est que vous pouvez taper directement le paramètre a=, OU vous pouvez laisser le paramètre en dehors de votre syntaxe et taper simplement le nom de votre tableau d’entrée.

Je vais vous montrer des exemples de ceci dans l’exemple 1.

axis

Le paramètre axis vous permet de spécifier un axe le long duquel l’écart type sera calculé.

Pour comprendre cela, vous devez vraiment comprendre les axes.

Les tableaux Numpy ont des axes.

Vous pouvez penser à un « axe » comme une direction le long du tableau.

Dans un tableau à 2 dimensions, il y aura 2 axes: axis-0 et axis-1.

Dans un tableau 2D, l’axe-0 pointe vers le bas le long des lignes et l’axe-1 pointe horizontalement le long des colonnes.

Visuellement, vous pouvez visualiser les axes d’un tableau 2D comme ceci:

Un exemple visuel d'axes de tableau NumPy.

En utilisant le paramètre axis, vous pouvez calculer l’écart-type dans une direction particulière le long du tableau.

Ceci est mieux illustré avec des exemples, donc je vais vous montrer un exemple dans l’exemple 2.

(Pour une explication complète des axes de tableau Numpy, consultez notre tutoriel intitulé Axes Numpy expliqués.)

dtype

(facultatif)
Le paramètre dtype vous permet de spécifier le type de données que vous souhaitez utiliser lorsque np.std calcule l’écart type.

Si les données du tableau d’entrée sont des entiers, la valeur par défaut sera float64.

Sinon, si les données du tableau d’entrée sont des flottants, le type float par défaut sera le même que le tableau d’entrée.

ddof

(facultatif)
Cela vous permet de spécifier les « degrés de liberté » pour le calcul.

Pour comprendre cela, vous devez regarder à nouveau l’équation 2.

\

Dans cette équation, le premier terme est \frac{1}{N}.

Rappelez-vous: N est le nombre de valeurs dans le tableau ou l’ensemble de données.

Mais si nous pensons en termes statistiques, il existe en fait une différence entre le calcul d’un écart-type de population et d’un écart-type d’échantillon.

Si nous calculons un écart type de population, nous utilisons le terme \frac{1}{N} dans notre équation.

Cependant, lorsque nous calculons l’écart-type sur un échantillon de données (un échantillon de n points de données), nous devons modifier l’équation de sorte que le terme principal soit \frac{1}{n-1}. Dans ce cas, l’équation pour un écart type d’échantillon devient :

\begin{equation*}s_{sample}=\sqrt{\frac{1}{n-1}\displaystyle\sum_{i= 1}^N(x_i-\overline{x})^2}\end{equation*}

Comment implémentons-nous cela avec np.mst?

Nous pouvons le faire avec le paramètre ddof, en définissant ddof = 1.

Et en fait, nous pouvons définir le terme ddof plus généralement. Lorsque nous utilisons ddof, il modifiera le calcul de l’écart type pour devenir:

\begin{equation*}\sqrt{\frac{1}{n-ddof}\displaystyle\sum_{i=1}^N(x_i-\ overline {x}) ^2}\end {equation*}

Pour être honnête, c’est un peu technique. Si vous avez besoin d’en savoir plus à ce sujet, vous devriez regarder cette vidéo à la Khan academy sur les degrés de liberté et l’écart type population / échantillon.

out

(facultatif)
Le paramètre out vous permet de spécifier un autre tableau dans lequel placer la sortie.

Il doit avoir la même forme que la sortie attendue.

keepdims

(facultatif)
Le paramètre keepdims peut être utilisé pour « conserver » le nombre de dimensions d’origine. Lorsque vous définissez keepdims = True, la sortie aura le même nombre de dimensions que l’entrée.

Rappelez-vous: lorsque nous calculons l’écart-type, le calcul « réduit » le nombre de dimensions.

Par exemple, si nous entrons un tableau à 2 dimensions en entrée, alors par défaut, np.std affichera un nombre. Une valeur scalaire.

Mais si nous voulons que la sortie soit un nombre dans un tableau 2D (c’est-à-dire un tableau de sortie avec les mêmes dimensions que l’entrée), alors nous pouvons définir keepdims = True.

Pour être honnête, certains de ces paramètres sont un peu abstraits, et je pense qu’ils auront beaucoup plus de sens avec des exemples.

Jetons un coup d’œil à quelques exemples.

Exemples d’utilisation de l’écart-type Numpy

Voici quelques exemples. Nous allons commencer simple, puis augmenter la complexité.

Exemples:

  • Calculer l’écart-type d’un tableau à 1 dimension
  • Calculer l’écart-type d’un tableau à 2 dimensions
  • Utiliser np.std pour calculer les écarts types des colonnes
  • Utilisez np.std pour calculer les écarts types des lignes
  • Modifiez les degrés de liberté
  • Utilisez le paramètre keepdims dans np.std

Exécutez d’abord ce code

Avant d’exécuter l’exemple de code, vous devez importer Numpy.

Pour ce faire, vous pouvez exécuter le code suivant: 

import numpy as np

Cela importera Numpy avec l’alias « np« .

EXEMPLE 1: Calculer l’écart type d’un tableau à 1 dimension

Ici, nous allons commencer simplement.

Nous allons calculer l’écart type du tableau Numpy à 1 dimension.

Créer un tableau 1D

Tout d’abord, nous allons simplement créer notre tableau 1D:

array_1d = np.array()
Calculer le dev standard

Maintenant, nous allons calculer l’écart type de ces nombres.

np.std(array_1d)

OUT:

30.84369195367723

Alors que s’est-il passé ici?

Le np.la fonction std vient de calculer l’écart type des nombres en utilisant l’équation 2 que nous avons vue plus tôt. Chaque nombre est l’un des x_i dans cette équation.

Une note rapide

Dans l’exemple ci-dessus, nous n’avons pas explicitement utilisé le paramètre a=. C’est parce que np.std comprend que lorsque nous fournissons un argument à la fonction comme dans le code np.std(array_1d), l’entrée doit être transmise au paramètre a.

Vous pouvez également utiliser explicitement le paramètre a=:

np.std(a = array_1d)

OUT: 

30.84369195367723

EXEMPLE 2: Calculer l’écart-type d’un tableau à 2 dimensions

Ok. Maintenant, regardons un exemple avec un tableau à 2 dimensions.

Créer un tableau à 2 dimensions

Ici, nous allons créer un tableau 2D, en utilisant le np.aléatoire.fonction randint.

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Ce tableau comporte 3 lignes et 4 colonnes.

Imprimons-le, afin que nous puissions le voir.

print(array_2d)

OUT:

 ]

Ceci est juste un tableau 2D qui contient 12 entiers aléatoires entre 0 et 20.

Calculer l’écart type avec np.std

D’accord, calculons l’écart type.

np.std(array_2d)

SORTIE:

5.007633062524539

Ici, numpy.std() ne fait que calculer l’écart-type des 12 entiers.

L’écart type est 5.007633062524539.

EXEMPLE 3: Calculer l’écart type des colonnes

Maintenant, nous allons calculer l’écart type des colonnes.

Pour ce faire, nous devons utiliser le paramètre axis. (Vous avez appris le paramètre axis dans la section sur les paramètres de numpy.std)

Plus précisément, nous devons définir axis = 0.

Pourquoi?

Comme je l’ai mentionné dans l’explication du paramètre axis précédemment, les tableaux Numpy ont des axes.

Dans un tableau bidimensionnel, l’axe-0 est l’axe qui pointe vers le bas.

Un tableau NumPy montrant que axis=0 est l'axe des lignes du tableau.

Lorsque nous utilisons numpy.std avec axis = 0, qui calculera les écarts types vers le bas dans la direction de l’axe 0.

Jetons un coup d’œil à un exemple pour que vous puissiez voir ce que je veux dire.

Créer un tableau à 2 dimensions

Tout d’abord, nous allons créer un tableau 2D, en utilisant le np.aléatoire.fonction randint.

(C’est le même tableau que nous avons créé dans l’exemple 2, donc si vous l’avez déjà créé, vous ne devriez pas avoir besoin de le créer à nouveau.)

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Imprimons-le, afin que nous puissions le voir.

print(array_2d)

OUT:

 ]

Ceci est juste un tableau 2D qui contient des entiers entre 0 et 20.

Utilisez np.std pour calculer l’écart type des colonnes

Maintenant, nous allons définir axis = 0 à l’intérieur de np.std pour calculer les écarts types des colonnes.

np.std(array_2d, axis = 0)

OUT:

array()
Explication

Que se passe-t-il ici?

Lorsque nous utilisons np.std avec axis = 0, Numpy calculera l’écart-type vers le bas dans la direction de l’axe 0. Rappelez-vous, comme je l’ai mentionné ci-dessus, l’axe-0 pointe vers le bas.

Ceci a pour effet de calculer l’écart type de chaque colonne du tableau Numpy.

Une image montrant comment utiliser l'écart-type Numpy avec axis=0 pour calculer les écarts-types de colonne.

Maintenant, faisons un exemple similaire avec les écarts types de ligne.

EXEMPLE 4 : Utilisez np.std pour calculer les écarts types des lignes

Maintenant, nous allons utiliser np.std pour calculer les écarts types horizontalement le long d’un tableau numpy 2D.

Rappelez-vous ce que j’ai dit plus tôt: les tableaux numpy ont des axes. Les axes sont comme des directions le long du tableau Numpy. Dans un tableau 2D, l’axe 1 pointe horizontalement, comme ceci:

Une image qui montre comment axis-1 pointe horizontalement le long d'un tableau numérique 2D.

Donc, si nous voulons calculer les écarts types horizontalement, nous pouvons définir axis = 1. Cela a pour effet de calculer les écarts types de ligne.

Jetons un coup d’œil.

Créer un tableau à 2 dimensions

Pour exécuter cet exemple, nous aurons à nouveau besoin d’un tableau Numpy 2D, nous allons donc créer un tableau 2D en utilisant le np.aléatoire.fonction randint.

(C’est le même tableau que nous avons créé dans l’exemple 2, donc si vous l’avez déjà créé, vous ne devriez pas avoir besoin de le créer à nouveau.)

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Imprimons-le, afin que nous puissions le voir.

print(array_2d)

OUT:

 ]

Ceci est juste un tableau 2D qui contient des entiers entre 0 et 20.

Utilisez np.std pour calculer l’écart type des lignes

Maintenant, nous allons utiliser np.std avec axis = 1 pour calculer les écarts types des lignes.

np.std(array_2d, axis = 1)

SORTIE:

array()
Explication

Si vous avez compris l’exemple 3, ce nouvel exemple devrait avoir du sens.

Lorsque nous utilisons np.std et set axis = 1, Numpy calculera les écarts types horizontalement le long de l’axe-1.

Une image qui montre en utilisant np.std avec axis=1 pour calculer les écarts types de ligne.

Effectivement, lorsque nous utilisons l’écart-type Numpy avec axis = 1, la fonction calcule l’écart-type des lignes.

EXEMPLE 5: Changez les degrés de liberté

Maintenant, changeons les degrés de liberté.

Dans cet exemple, nous allons créer un grand tableau de nombres, prendre un échantillon de ce tableau et calculer l’écart-type sur cet échantillon.

D’abord, créons nos tableaux.

Créer un tableau Numpy

Tout d’abord, nous allons simplement créer un tableau Numpy normalement distribué avec une moyenne de 0 et un écart type de 10.

Pour ce faire, nous utiliserons la fonction normale aléatoire Numpy. Notez que nous utilisons la fonction Numpy random seed pour définir la graine du générateur de nombres aléatoires. Pour plus d’informations à ce sujet, lisez notre tutoriel sur np.aléatoire.graine.

np.random.seed(22)population_array = np.random.normal(size = 100, loc = 0, scale = 10)

Ok. Maintenant, nous avons un tableau Numpy, population_array, qui a 100 éléments qui ont une moyenne de 0 et un écart-type de 10.

Créer un échantillon

Maintenant, nous allons utiliser Numpy random choice pour prendre un échantillon aléatoire du tableau Numpy, population_array.

np.random.seed(22)sample_array = np.random.choice(population_array, size = 10)

Ce nouveau tableau, sample_array, est un échantillon aléatoire de 10 éléments de population_array.

Nous utiliserons sample_arraylorsque nous calculerons notre écart type en utilisant le paramètre ddof.

Calculez l’écart type de l’échantillon

Maintenant, nous allons calculer l’écart type de l’échantillon.

Plus précisément, nous allons utiliser la fonction d’écart-type Numpy avec le paramètre ddof défini sur ddof = 1.

np.std(sample_array, ddof = 1)

OUT:

10.703405562234051
Explication

Ici, nous avons calculé:

\

Et lorsque nous définissons ddof = 1, l’équation s’évalue à :

\

Pour être clair, lorsque vous calculez l’écart type d’un échantillon, vous définissez ddof = 1.

Pour être honnête, les détails sur les raisons sont un peu techniques (et dépassent le cadre de cet article), donc pour plus d’informations sur le calcul d’un échantillon d’écart-type, je vous recommande de regarder cette vidéo.

Gardez à l’esprit que pour certaines autres instances, vous pouvez définir ddof sur d’autres valeurs que 1 ou 0. Si vous n’utilisez pas du tout le paramètre ddof, il sera par défaut à 0.

Quelle que soit la valeur que vous sélectionnez, la fonction d’écart-type Numpy calculera l’écart-type avec l’équation :

\

EXEMPLE 6: Utilisez le paramètre keepdims dans np.dst

Ok. Enfin, nous ferons un dernier exemple.

Ici, nous allons définir le paramètre keepdims sur keepdims = True.

Créer un tableau à 2 dimensions

Tout d’abord, nous allons créer un tableau 2D, en utilisant le np.aléatoire.fonction randint.

(C’est le même tableau que nous avons créé dans l’exemple 2, donc si vous l’avez déjà créé, vous ne devriez pas avoir besoin de le créer à nouveau.)

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Imprimons-le:

print(array_2d)

OUT: 

 ]
Vérifiez les dimensions

Maintenant, examinons les dimensions de ce tableau.

array_2d.ndim

OUT:

2

Ceci est un tableau 2D, tout comme nous l’avions prévu.

Calculez l’écart type et vérifiez les dimensions

Ok. Maintenant, nous allons calculer l’écart-type et vérifier les dimensions de la sortie.

output = np.std(array_2d)

Imprimons rapidement la sortie:

print(output)

OUT: 

5.007633062524539

L’écart type est donc de 5,007633062524539.

Maintenant, quelles sont les dimensions de la sortie?

output.ndim

SORTIE:

0

La sortie a 0 dimensions (c’est une valeur scalaire).

Pourquoi?

Lorsque np.std calcule l’écart type, il calcule une statistique récapitulative. Dans ce cas, la fonction prend un grand nombre de valeurs et les réduit à une seule métrique.

Donc l’entrée était à 2 dimensions, mais la sortie est à 0 dimension.

Et si nous voulons changer cela?

Que se passe-t-il si nous voulons que la sortie ait techniquement des dimensions 2?

Nous pouvons le faire avec le paramètre keepdims.

Conservez les dimensions d’origine lorsque nous utilisons np.std

Ici, nous allons définir keepdims = True pour que la sortie ait les mêmes dimensions que l’entrée.

output_2d = np.std(array_2d, keepdims = True)

Maintenant, regardons la sortie: 

print(output_2d)

OUT: 

]

Notez que la sortie, l’écart type, est toujours 5.00763306. Mais le résultat est enfermé à l’intérieur de doubles supports.

Inspectons output_2d et regardons de plus près.

type(output_2d)

OUT:

numpy.ndarray

Donc, output_2d est un tableau Numpy, pas une valeur scalaire.

Vérifions les dimensions:

output_2d.ndim

OUT:

2

Ce tableau Numpy, output_2d, a 2 dimensions.

Il s’agit du même nombre de dimensions que l’entrée.

Que s’est-il passé ?

Lorsque nous définissons keepdims = True, cela a provoqué le np.fonction std pour produire une sortie avec le même nombre de dimensions que l’entrée. Même s’il n’y a pas de lignes et de colonnes dans la sortie, la sortie output_2d a 2 dimensions.

Ainsi, au cas où vous auriez besoin que votre sortie ait le même nombre de dimensions que votre entrée, vous pouvez définir keepdims = True.

(Cela fonctionne également lorsque vous utilisez le paramètre axis try essayez-le!)

Foire aux questions sur l’écart-type Numpy

Maintenant que vous avez appris sur l’écart-type Numpy et vu quelques exemples, passons en revue quelques questions fréquemment posées sur np.MST.

Foire aux questions:

  • Pourquoi numpy std() donne-t-il un résultat différent de matlab std() ou d’un autre langage de programmation?

Question 1: Pourquoi numpy std() donne-t-il un résultat différent de matlab std() ou d’un autre langage de programmation?

La raison simple est que matlab calcule le dev standard selon ce qui suit :

\

(De nombreux autres outils utilisent la même équation.)

Cependant, Numpy calcule avec ce qui suit:

\

Notez la différence subtile entre le \frac{1}{n-1} par rapport au \frac{1}{N}.

Pour résoudre ce problème, vous pouvez utiliser le paramètre ddof dans Numpy.

Si vous utilisez np.std avec le paramètre ddof défini sur ddof = 1, vous devriez obtenir la même réponse que matlab.

Laissez vos autres questions dans les commentaires ci-dessous

Avez-vous d’autres questions sur la fonction d’écart type Numpy?

Laissez votre question dans la section commentaires ci-dessous.

Rejoignez notre cours pour en savoir plus sur Numpy

Les exemples que vous avez vus dans ce tutoriel devraient suffire à vous aider à démarrer, mais si vous voulez vraiment apprendre Numpy, vous devriez vous inscrire à notre cours premium appelé Maîtrise Numpy.

Il y a beaucoup plus à apprendre sur Numpy, et la maîtrise de Numpy vous apprendra tout, y compris:

  • Comment créer des tableaux Numpy
  • Comment utiliser les fonctions aléatoires Numpy
  • Ce que fait la fonction « Graine aléatoire Numpy »
  • Comment remodeler, diviser et combiner vos tableaux Numpy
  • et plus encore

De plus, cela vous aidera à maîtriser complètement la syntaxe en quelques semaines. Vous découvrirez comment devenir « courant » dans l’écriture du code Numpy.

En savoir plus ici:

En savoir plus Sur La Maîtrise Numpy