NumPy Tutorial : Analyse de données avec Python

Ne manquez pas notre antisèche GRATUITE de NumPy au bas de ce post

NumPy est un package d’analyse de données Python couramment utilisé. En utilisant NumPy, vous pouvez accélérer votre flux de travail, et vous interfacer avec d’autres paquets dans l’écosystème Python, comme scikit-learn, qui utilisent NumPy sous le capot. NumPy a été développé au milieu des années 2000 et est issu d’un paquet encore plus ancien appelé Numeric. Cette longévité signifie que presque tous les paquets d’analyse de données ou d’apprentissage automatique pour Python exploitent NumPy d’une manière ou d’une autre.

Dans ce tutoriel, nous allons marcher à travers l’utilisation de NumPy pour analyser les données sur la qualité du vin. Les données contiennent des informations sur divers attributs des vins, tels que pH et fixed acidity, ainsi qu’un score de qualité compris entre 0 et 10 pour chaque vin. La note de qualité est la moyenne d’au moins 3 testeurs de goût humains. Au fur et à mesure que nous apprendrons à travailler avec NumPy, nous essaierons d’en savoir plus sur la qualité perçue du vin.

Les vins que nous analyserons proviennent de la région de Minho au Portugal.

Les données ont été téléchargées à partir du dépôt d’apprentissage machine de l’UCI, et sont disponibles ici. Voici les premières lignes du fichier winequality-red.csv, que nous utiliserons tout au long de ce tutoriel :

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

Les données sont dans ce que je vais appeler le format ssv (semicolon separated values) – chaque enregistrement est séparé par un point-virgule (;), et les lignes sont séparées par une nouvelle ligne. Il y a 1600 lignes dans le fichier, y compris une ligne d’en-tête, et 12 colonnes.

Avant de commencer, une note rapide sur la version – nous utiliserons Python 3.5. Nos exemples de code seront faits en utilisant le carnet Jupyter.

Listes de listes pour les données CSV

Avant d’utiliser NumPy, nous allons d’abord essayer de travailler avec les données en utilisant Python et le package csv. Nous pouvons lire le fichier en utilisant l’objet csv.reader, qui nous permettra de lire et de diviser tout le contenu du fichier ssv.

Dans le code ci-dessous, nous :

• Importons la bibliothèque csv.
• Ouvrons le fichier winequality-red.csv.
  • Avec le fichier ouvert, créons un nouvel objet csv.reader.
    • Passez l’argument mot-clé delimiter=";" pour vous assurer que les enregistrements sont séparés sur le caractère point-virgule au lieu du caractère virgule par défaut.
  • Appellez le type liste pour obtenir toutes les lignes du fichier.
  • Assignez le résultat à wines.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

Une fois que nous avons lu les données, nous pouvons imprimer les premières 3 lignes:

print(wines)

, , ]

Les données ont été lues dans une liste de listes. Chaque liste intérieure est une ligne du fichier ssv. Comme vous avez pu le remarquer, chaque élément de toute la liste de listes est représenté comme une chaîne de caractères, ce qui rendra plus difficile les calculs.

Nous allons formater les données dans un tableau pour les rendre plus faciles à visualiser :

Comme vous pouvez le voir dans le tableau ci-dessus, nous avons lu trois lignes, dont la première contient les en-têtes de colonne. Chaque ligne après la ligne d’en-tête représente un vin. Le premier élément de chaque ligne est le fixed acidity, le deuxième est le volatile acidity, et ainsi de suite. Nous pouvons trouver la moyenne quality des vins. Le code ci-dessous va :

• Extraire le dernier élément de chaque ligne après la ligne d’en-tête.
• Convertir chaque élément extrait en un flottant.
• Assigner tous les éléments extraits à la liste qualities.
• Diviser la somme de tous les éléments dans qualities par le nombre total d’éléments dans qualities pour obtenir la moyenne.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Bien que nous ayons pu faire le calcul que nous voulions, le code est assez complexe, et il ne sera pas amusant de devoir faire quelque chose de similaire chaque fois que nous voulons calculer une quantité. Heureusement, nous pouvons utiliser NumPy pour faciliter le travail avec nos données.

Numpy tableaux à 2 dimensions

Avec NumPy, nous travaillons avec des tableaux multidimensionnels. Nous allons plonger dans tous les types possibles de tableaux multidimensionnels plus tard, mais pour l’instant, nous allons nous concentrer sur les tableaux à 2 dimensions. Un tableau à deux dimensions est également connu sous le nom de matrice, et vous devriez vous y connaître. En fait, il s’agit simplement d’une façon différente de penser à une liste de listes. Une matrice comporte des lignes et des colonnes. En spécifiant un numéro de ligne et un numéro de colonne, nous sommes en mesure d’extraire un élément d’une matrice.

Dans la matrice ci-dessous, la première ligne est la ligne d’en-tête, et la première colonne est la colonne fixed acidity :

Si nous prenions l’élément à la première ligne et à la deuxième colonne, nous obtiendrions volatile acidity. Si nous choisissions l’élément à la troisième ligne et à la deuxième colonne, nous obtiendrions 0.88.

Dans un tableau NumPy, le nombre de dimensions est appelé le rang, et chaque dimension est appelée un axe. Donc, les rangs sont le premier axe, et les colonnes sont le deuxième axe.

Maintenant que vous comprenez les bases des matrices, voyons comment nous pouvons passer de notre liste de listes à un tableau NumPy.

Création d’un tableau NumPy

Nous pouvons créer un tableau NumPy en utilisant la fonction numpy.array. Si nous lui passons une liste de listes, elle créera automatiquement un tableau NumPy avec le même nombre de lignes et de colonnes. Comme nous voulons que tous les éléments du tableau soient des éléments flottants pour faciliter les calculs, nous ne tiendrons pas compte de la ligne d’en-tête, qui contient des chaînes de caractères. Une des limitations de NumPy est que tous les éléments d’un tableau doivent être du même type, donc si nous incluons la ligne d’en-tête, tous les éléments du tableau seront lus comme des chaînes de caractères. Parce que nous voulons pouvoir faire des calculs comme trouver la moyenne qualitydes vins, nous avons besoin que les éléments soient tous des flottants.

Dans le code ci-dessous, nous :

• Importons le paquet numpy.
• Passons la liste de listes wines dans la fonction array, qui la convertit en un tableau NumPy.
  • Excluons la ligne d’en-tête avec le découpage en listes.
  • Spécifions l’argument mot-clé dtype pour nous assurer que chaque élément est converti en un flottant. Nous plongerons plus loin dans ce qu’est le dtype.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

Essayez d’exécuter le code ci-dessus et voyez ce qui se passe !

Si nous affichons wines, nous obtiendrons maintenant un tableau NumPy :

wines

array(,,,...,,,])

Nous pouvons vérifier le nombre de lignes et de colonnes dans nos données en utilisant la propriété shape des tableaux NumPy :

wines.shape

(1599, 12)

Méthodes alternatives de création de tableaux NumPy

Il existe une variété de méthodes que vous pouvez utiliser pour créer des tableaux NumPy. Pour commencer, vous pouvez créer un tableau où chaque élément est égal à zéro. Le code ci-dessous créera un tableau avec 3 lignes et 4 colonnes, où chaque élément est 0, en utilisant numpy.zeros:

import numpy as np

empty_array = np.zeros((3,4)) empty_array

Il est utile de créer un tableau avec tous les éléments zéro dans les cas où vous avez besoin d’un tableau de taille fixe, mais n’avez pas encore de valeurs pour lui.

Vous pouvez également créer un tableau où chaque élément est un nombre aléatoire en utilisant numpy.random.rand. Voici un exemple :

np.random.rand(3,4)

array(,,])

Créer des tableaux remplis de nombres aléatoires peut être utile lorsque vous voulez tester rapidement votre code avec des tableaux échantillons.

Utiliser NumPy pour lire dans des fichiers

Il est possible d’utiliser NumPy pour lire directement des fichiers csv ou autres dans des tableaux. Nous pouvons le faire en utilisant la fonction numpy.genfromtxt. Nous pouvons l’utiliser pour lire nos données initiales sur les vins rouges.

Dans le code ci-dessous, nous :

• Utilisons la fonction genfromtxt pour lire le fichier winequality-red.csv.
• Spécifions l’argument mot-clé delimiter=";" afin que les champs soient analysés correctement.
• Spécifiez l’argument mot-clé skip_header=1 pour que la ligne d’en-tête soit sautée.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

wines finira par avoir le même aspect que si nous l’avions lu dans une liste puis converti en un tableau de flottants. NumPy choisira automatiquement un type de données pour les éléments d’un tableau en fonction de leur format.

Indexation de tableaux NumPy

Nous savons maintenant comment créer des tableaux, mais à moins que nous puissions récupérer des résultats à partir de ceux-ci, il n’y a pas beaucoup de choses que nous pouvons faire avec NumPy. Nous pouvons utiliser l’indexation des tableaux pour sélectionner des éléments individuels, des groupes d’éléments ou des lignes et des colonnes entières. Une chose importante à garder à l’esprit est que, tout comme les listes Python, NumPy est indexé à zéro, ce qui signifie que l’index de la première ligne est 0, et l’index de la première colonne est 0. Si nous voulons travailler avec la quatrième ligne, nous utiliserons l’index 3, si nous voulons travailler avec la deuxième ligne, nous utiliserons l’index 1, et ainsi de suite. Nous allons à nouveau travailler avec le tableau wines :

Sélectionnons l’élément à la ligne 3 et à la colonne 4. Dans le code ci-dessous, nous passons l’indice 2 comme indice de ligne, et l’indice 3 comme indice de colonne. Ceci récupère la valeur de la quatrième colonne de la troisième ligne :

wines

2.2999999999999998

Comme nous travaillons avec un tableau à 2 dimensions dans NumPy, nous spécifions 2 index pour récupérer un élément. Le premier indice est l’indice de ligne, ou axe 1, et le second indice est l’indice de colonne, ou axe 2,. Tout élément dans wines peut être récupéré en utilisant les index 2.

Slicing NumPy Arrays

Si nous voulons plutôt sélectionner les trois premiers éléments de la quatrième colonne, nous pouvons le faire en utilisant un deux-points (:). Un deux-points indique que nous voulons sélectionner tous les éléments de l’indice de départ jusqu’à l’indice de fin non compris. Ceci est également connu comme une tranche:

wines

array()

Comme pour la tranche de liste, il est possible d’omettre le 0 pour juste récupérer tous les éléments du début jusqu’à l’élément 3:

wines

array()

Nous pouvons sélectionner une colonne entière en spécifiant que nous voulons tous les éléments, du premier au dernier. Nous le spécifions en utilisant simplement les deux points (:), sans indices de début ou de fin. Le code ci-dessous sélectionnera la quatrième colonne entière:

wines

array()

Nous avons sélectionné une colonne entière ci-dessus, mais nous pouvons également extraire une ligne entière:

wines

array()

Si nous poussons notre indexation à l’extrême, nous pouvons sélectionner le tableau entier en utilisant deux deux-points pour sélectionner toutes les lignes et colonnes dans wines. C’est un super truc de fête, mais qui n’a pas beaucoup de bonnes applications:

wines

array(,,<br />,<br />...,,,<br />])

Affecter des valeurs aux tableaux NumPy

Nous pouvons également utiliser l’indexation pour affecter des valeurs à certains éléments des tableaux. Nous pouvons le faire en assignant directement à la valeur indexée :

wines = 10

Nous pouvons faire de même pour les tranches. Pour écraser une colonne entière, nous pouvons faire ceci:

wines = 50

Le code ci-dessus écrase toutes les valeurs de la onzième colonne avec 50.

Tableaux NumPy à 1 dimension

Jusqu’ici, nous avons travaillé avec des tableaux à 2 dimensions, comme wines. Cependant, NumPy est un package permettant de travailler avec des tableaux multidimensionnels. L’un des types les plus courants de tableaux multidimensionnels est le tableau à 1 dimension, ou vecteur. Comme vous l’avez peut-être remarqué ci-dessus, lorsque nous avons découpé wines, nous avons récupéré un tableau à une dimension. Un tableau à 1 dimension n’a besoin que d’un seul index pour récupérer un élément. Chaque ligne et colonne d’un tableau à 2 dimensions est un tableau à 1 dimension. Tout comme une liste de listes est analogue à un tableau à deux dimensions, une liste unique est analogue à un tableau à une dimension. Si nous découpons des vins et ne récupérons que la troisième ligne, nous obtenons un tableau à 1 dimension :

third_wine = wines

Voici à quoi ressemble third_wine :

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Nous pouvons récupérer des éléments individuels de third_wine en utilisant un seul index. Le code ci-dessous affichera le deuxième élément de third_wine:

third_wine

0.28000000000000003

La plupart des fonctions NumPy avec lesquelles nous avons travaillé, telles que numpy.random.rand, peuvent être utilisées avec des tableaux multidimensionnels. Voici comment nous utiliserions numpy.random.rand pour générer un vecteur aléatoire:

np.random.rand(3)

array()

Auparavant, lorsque nous avons appelé np.random.rand, nous avons passé dans une forme pour un tableau à 2 dimensions, donc le résultat était un tableau à 2 dimensions. Cette fois, nous avons passé dans une forme pour un tableau à une dimension. La forme spécifie le nombre de dimensions, et la taille du tableau dans chaque dimension. Une forme de (10,10) sera un tableau à 2 dimensions avec 10 lignes et 10 colonnes. Une forme de (10,) sera un tableau à 1 dimension avec 10 éléments.

Là où NumPy devient plus complexe, c’est lorsque nous commençons à traiter des tableaux qui ont plus de 2 dimensions.

Tableaux NumPy à N dimensions

Cela n’arrive pas extrêmement souvent, mais il y a des cas où vous voudrez traiter des tableaux qui ont plus de 3 dimensions. Une façon de penser à cela est comme une liste de listes de listes. Imaginons que nous voulions stocker les revenus mensuels d’un magasin, mais que nous voulions pouvoir consulter rapidement les résultats pour un trimestre et une année. Les gains pour une année pourraient ressembler à ceci :

Le magasin a gagné 0 en janvier, 5 en février, et ainsi de suite. Nous pouvons diviser ces gains par trimestre en une liste de listes :

year_one = , , , ]

Nous pouvons récupérer les gains de janvier en appelant year_one. Si nous voulons les résultats d’un trimestre entier, nous pouvons appeler year_one ou year_one. Nous avons maintenant un tableau, ou une matrice, à 2 dimensions. Mais que faire si nous voulons maintenant ajouter les résultats d’une autre année ? Nous devons ajouter une troisième dimension:

earnings = , , , ], , , , ]]

Nous pouvons récupérer les résultats de janvier de la première année en appelant earnings. Nous avons maintenant besoin de trois index pour récupérer un seul élément. Un tableau tridimensionnel dans NumPy est à peu près le même. En fait, nous pouvons convertir earnings en un tableau et ensuite obtenir les gains de janvier de la première année :

earnings = np.array(earnings)earnings

500

Nous pouvons également trouver la forme du tableau :

earnings.shape

(2, 4, 3)

L’indexation et le découpage fonctionnent exactement de la même manière avec un tableau tridimensionnel, mais nous avons maintenant un axe supplémentaire à passer. Si nous voulions obtenir les bénéfices pour le mois de janvier de toutes les années, nous pourrions faire ceci:

earnings

array()

Si nous voulions obtenir les bénéfices du premier trimestre des deux années, nous pourrions faire ceci:

earnings

array(,])

Ajouter plus de dimensions peut rendre beaucoup plus facile l’interrogation de vos données si elles sont organisées d’une certaine façon. Lorsque nous passons de tableaux à 3 dimensions à des tableaux à 4 dimensions et plus grands, les mêmes propriétés s’appliquent, et ils peuvent être indexés et découpés de la même manière.

Types de données NumPy

Comme nous l’avons mentionné précédemment, chaque tableau NumPy peut stocker des éléments d’un seul type de données. Par exemple, wines ne contient que des valeurs flottantes. NumPy stocke les valeurs en utilisant ses propres types de données, qui sont distincts des types Python comme float et str. Cela est dû au fait que le noyau de NumPy est écrit dans un langage de programmation appelé C, qui stocke les données différemment des types de données Python. Les types de données NumPy s’adaptent entre Python et C, ce qui nous permet d’utiliser les tableaux NumPy sans problème de conversion.

Vous pouvez trouver le type de données d’un tableau NumPy en accédant à la propriété dtype:

wines.dtype

dtype('float64')

NumPy a plusieurs types de données différents, qui s’adaptent principalement aux types de données Python, comme float et str. Vous pouvez trouver une liste complète des types de données NumPy ici, mais voici quelques types importants :

• float – données numériques à virgule flottante.
• int – données entières.
• string – données de caractères.
• object – objets Python.

Les types de données se terminent en outre par un suffixe qui indique combien de bits de mémoire ils occupent. Ainsi, int32 est un type de données entier 32 bits, et float64 est un type de données flottant 64 bits.

Conversion des types de données

Vous pouvez utiliser la méthode numpy.ndarray.astype pour convertir un tableau en un type différent. La méthode va effectivement copier le tableau, et retourner un nouveau tableau avec le type de données spécifié. Par exemple, nous pouvons convertir wines au type de données int:

wines.astype(int)

array(,,,...,,,])

Comme vous pouvez le voir ci-dessus, tous les éléments du tableau résultant sont des entiers. Notez que nous avons utilisé le type Python int au lieu d’un type de données NumPy lors de la conversion de wines. En effet, plusieurs types de données Python, notamment float, int et string, peuvent être utilisés avec NumPy et sont automatiquement convertis en types de données NumPy.

Nous pouvons vérifier la propriété name du dtype du tableau résultant pour voir à quel type de données NumPy a mappé le tableau résultant :

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

Le tableau a été converti en un type de données entier 64 bits. Cela permet des valeurs entières très longues, mais prend plus d’espace en mémoire que le stockage des valeurs en tant qu’entiers 32 bits.

Si vous voulez plus de contrôle sur la façon dont le tableau est stocké en mémoire, vous pouvez directement créer des objets de type NumPy comme numpy.int32:

np.int32

numpy.int32

Vous pouvez les utiliser directement pour convertir entre les types:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

NumPy Array Operations

NumPy rend simple l’exécution d’opérations mathématiques sur les tableaux. C’est l’un des principaux avantages de NumPy, et il rend assez facile de faire des calculs.

Single Array Math

Si vous faites l’une des opérations mathématiques de base (/, *, -, +, ^) avec un tableau et une valeur, il appliquera l’opération à chacun des éléments du tableau.

Disons que nous voulons ajouter 10 points à chaque score de qualité parce que nous sommes ivres et que nous nous sentons généreux. Voici comment nous le ferions :

wines + 10

array()

Notez que l’opération ci-dessus ne changera pas le tableau wines – elle retournera un nouveau tableau à 1 dimension où 10 a été ajouté à chaque élément de la colonne de qualité des vins.

Si nous faisions plutôt +=, nous modifierions le tableau à la place :

wines += 10wines

array()

Toutes les autres opérations fonctionnent de la même manière. Par exemple, si nous voulons multiplier chacun des scores de qualité par 2, nous pourrions le faire comme ceci:

wines * 2

array()

Multiple Array Math

Il est également possible de faire des opérations mathématiques entre tableaux. Cela appliquera l’opération à des paires d’éléments. Par exemple, si nous ajoutons la colonne quality à elle-même, voici ce que nous obtenons :

wines + wines

array()

Notez que cela est équivalent à wines * 2 – c’est parce que NumPy ajoute chaque paire d’éléments. Le premier élément du premier tableau est ajouté au premier élément du deuxième tableau, le deuxième au deuxième, et ainsi de suite.

Nous pouvons également utiliser ceci pour multiplier des tableaux. Disons que nous voulons choisir un vin qui maximise la teneur en alcool et la qualité (nous voulons être ivres, mais nous avons de la classe). Nous multiplierions alcohol par quality, et sélectionnerions le vin ayant le score le plus élevé :

wines * wines

array()

Toutes les opérations courantes (/, *, -, +, ^) fonctionneront entre tableaux.

Diffusion

À moins que les tableaux sur lesquels vous opérez soient exactement de la même taille, il n’est pas possible de faire des opérations par éléments. Dans des cas comme celui-ci, NumPy effectue une diffusion pour essayer de faire correspondre les éléments. Essentiellement, la diffusion implique quelques étapes :

• La dernière dimension de chaque tableau est comparée.
  • Si les longueurs des dimensions sont égales, ou si l’une des dimensions est de longueur 1, alors on continue.
  • Si les longueurs des dimensions ne sont pas égales, et si aucune des dimensions n’a de longueur 1, alors il y a une erreur.
• On continue à vérifier les dimensions jusqu’à ce que le tableau le plus court n’ait plus de dimensions.

Par exemple, les deux formes suivantes sont compatibles:

A: (50,3)B (3,)

C’est parce que la longueur de la dimension de queue du tableau A est 3, et la longueur de la dimension de queue du tableau B est 3. Elles sont égales, donc cette dimension est correcte. Le tableau B n’a alors plus d’éléments, donc on est d’accord, et les tableaux sont compatibles pour les opérations mathématiques.

Les deux formes suivantes sont également compatibles :

A: (1,2)B (50,2)

La dernière dimension correspond, et A est de longueur 1 dans la première dimension.

Ces deux tableaux ne sont pas compatibles:

A: (50,50)B: (49,49)

Les longueurs des dimensions ne sont pas égales, et aucun des tableaux n’a une longueur de dimension égale à 1.

Il y a une explication détaillée de la diffusion ici, mais nous allons passer par quelques exemples pour illustrer le principe:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

L’exemple ci-dessus n’a pas fonctionné parce que les deux tableaux n’ont pas de dimension de queue correspondante. Voici un exemple où la dernière dimension correspond effectivement:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

Comme vous pouvez le voir, array_two a été diffusé sur chaque ligne de array_one. Voici un exemple avec nos données wines:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Les éléments de rand_array sont diffusés sur chaque ligne de wines, donc la première colonne de wines se voit ajouter la première valeur de rand_array, et ainsi de suite.

Méthodes de tableaux de NumPy

En plus des opérations mathématiques courantes, NumPy possède également plusieurs méthodes que vous pouvez utiliser pour des calculs plus complexes sur des tableaux. Un exemple de ceci est la méthode numpy.ndarray.sum. Celle-ci trouve par défaut la somme de tous les éléments d’un tableau :

wines.sum()

9012.0

Le total de toutes nos notes de qualité est 154.1788. Nous pouvons passer l’argument du mot-clé axis dans la méthode sum pour trouver des sommes sur un axe. Si nous appelons sum à travers la matrice wines, et passons axis=0, nous trouverons les sommes sur le premier axe du tableau. Cela nous donnera la somme de toutes les valeurs de chaque colonne. Cela peut sembler paradoxal que les sommes sur le premier axe nous donnent la somme de chaque colonne, mais une façon de voir les choses est que l’axe spécifié est celui qui « s’en va ». Donc, si nous spécifions axis=0, nous voulons que les lignes s’en aillent, et nous voulons trouver les sommes pour chacun des axes restants à travers chaque ligne:

wines.sum(axis=0)

array()

Nous pouvons vérifier que nous avons fait la somme correctement en vérifiant la forme. La forme devrait être 12, correspondant au nombre de colonnes:

wines.sum(axis=0).shape

(12,)

Si nous passons dans axis=1, nous trouverons les sommes sur le deuxième axe du tableau. Cela nous donnera la somme de chaque ligne :

wines.sum(axis=1)

array()

Il existe plusieurs autres méthodes qui se comportent comme la méthode sum, notamment :

• numpy.ndarray.mean – trouve la moyenne d’un tableau.
• numpy.ndarray.std – trouve l’écart type d’un tableau.
• numpy.ndarray.min – trouve la valeur minimale dans un tableau.
• numpy.ndarray.max – trouve la valeur maximale dans un tableau.

Vous pouvez trouver une liste complète des méthodes de tableau ici.

NumPy Array Comparisons

NumPy permet de tester pour voir si les lignes correspondent à certaines valeurs en utilisant des opérations de comparaison mathématiques comme <, >, >=, <= et ==. Par exemple, si nous voulons voir quels vins ont une note de qualité supérieure à 5, nous pouvons faire ceci :

wines > 5

array(, dtype=bool)

Nous obtenons un tableau booléen qui nous indique quels vins ont une note de qualité supérieure à 5. Nous pouvons faire quelque chose de similaire avec les autres opérateurs. Par exemple, nous pouvons voir si des vins ont une note de qualité égale à 10:

wines == 10

array(, dtype=bool)

Subsetting

Une des choses puissantes que nous pouvons faire avec un tableau booléen et un tableau NumPy est de sélectionner seulement certaines lignes ou colonnes dans le tableau NumPy. Par exemple, le code ci-dessous ne sélectionnera que les lignes de wines où la qualité est supérieure à 7:

high_quality = wines > 7wines

array(,,])

Nous ne sélectionnons que les lignes où high_quality contient une valeur True, et toutes les colonnes. Ce sous-ensemble permet de filtrer facilement des tableaux pour certains critères. Par exemple, nous pouvons rechercher des vins avec beaucoup d’alcool et de haute qualité. Afin de spécifier plusieurs conditions, nous devons placer chaque condition entre parenthèses et séparer les conditions par une esperluette (&):

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Nous pouvons combiner le sous-ensemble et l’affectation pour écraser certaines valeurs dans un tableau:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

Reshaping NumPy Arrays

Nous pouvons modifier la forme des tableaux tout en conservant tous leurs éléments. Cela peut souvent faciliter l’accès aux éléments du tableau. Le remodelage le plus simple consiste à inverser les axes, de sorte que les lignes deviennent des colonnes, et vice versa. Nous pouvons accomplir cela avec la fonction numpy.transpose:

np.transpose(wines).shape

(12, 1599)

Nous pouvons utiliser la fonction numpy.ravel pour transformer un tableau en une représentation unidimensionnelle. Elle va essentiellement aplatir un tableau en une longue séquence de valeurs:

wines.ravel()

array()

Voici un exemple où nous pouvons voir l’ordre de numpy.ravel:

array_one = np.array( , ])array_one.ravel()

array()

Enfin, nous pouvons utiliser la fonction numpy.reshape pour remodeler un tableau à une certaine forme que nous spécifions. Le code ci-dessous transformera la deuxième ligne de wines en un tableau à 2 dimensions avec 2 lignes et 6 colonnes:

wines.reshape((2,6))

array(,])

Combinaison de tableaux NumPy

Avec NumPy, il est très courant de combiner plusieurs tableaux en un seul tableau unifié. Nous pouvons utiliser numpy.vstack pour empiler verticalement plusieurs tableaux. Pensez-y comme si les éléments du tableau étaient ajoutés comme de nouvelles lignes au premier tableau. Nous pouvons lire le jeu de données winequality-white.csv qui contient des informations sur la qualité des vins blancs, puis le combiner avec notre jeu de données existant, wines, qui contient des informations sur les vins rouges.

Dans le code ci-dessous, nous :

• Lisons dans winequality-white.csv.
• Affichons la forme de white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

Comme vous pouvez le voir, nous avons des attributs pour les 4898 vins. Maintenant que nous avons les données sur les vins blancs, nous pouvons combiner toutes les données sur les vins.

Dans le code ci-dessous, nous :

• Utilisons la fonction vstack pour combiner wines et white_wines.
• Affichons la forme du résultat.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

Comme vous pouvez le voir, le résultat a 6497lignes, ce qui est la somme du nombre de lignes dans wines et du nombre de lignes dans red_wines.

Si nous voulons combiner des tableaux horizontalement, où le nombre de lignes reste constant, mais les colonnes sont jointes, alors nous pouvons utiliser la fonction numpy.hstack. Les tableaux que nous combinons doivent avoir le même nombre de lignes pour que cela fonctionne.

Enfin, nous pouvons utiliser numpy.concatenate comme une version générale de hstack et vstack. Si nous voulons concaténer deux tableaux, nous les passons dans concatenate, puis nous spécifions l’argument du mot-clé axis le long duquel nous voulons concaténer. La concaténation le long du premier axe est similaire à vstack, et la concaténation le long du deuxième axe est similaire à hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Free NumPy Cheat Sheet

Si vous souhaitez en apprendre davantage sur NumPy, consultez notre cours interactif sur NumPy et Pandas. Vous pouvez vous inscrire et faire les premières missions gratuitement.

Vous pourriez aussi aimer faire passer vos compétences NumPy au niveau supérieur avec notre antisèche NumPy gratuite !

Lectures complémentaires

Vous devriez maintenant avoir une bonne maîtrise de NumPy, et savoir comment l’appliquer à un ensemble de données.

Si vous voulez plonger plus en profondeur, voici quelques ressources qui peuvent être utiles :

• NumPy Quickstart – a de bons exemples de code et couvre la plupart des fonctionnalités de base de NumPy.
• Tutoriel Python NumPy – un excellent tutoriel sur NumPy et d’autres bibliothèques Python.
• Introduction visuelle de NumPy – un guide qui utilise le jeu de la vie pour illustrer les concepts de NumPy.

Dans notre prochain tutoriel, nous plongeons davantage dans Pandas, une bibliothèque qui s’appuie sur NumPy et rend l’analyse de données encore plus facile. Elle résout deux des plus grands points de douleur qui sont que :

• Vous ne pouvez pas mélanger plusieurs types de données dans un tableau.
• Vous devez vous rappeler quel type de données chaque colonne contient.

.