Vous souhaitez devenir Data Analyst ou Data Scientist ? Vous voulez faire des analyses de données avec python ? Ou vous souhaitez utiliser Python pour trouver des solutions à quelques problèmes du monde réel ? Alors, sachez que NumPy de Python est l’une des bibliothèques que vous devez connaître et utiliser si vous voulez faire de la science des données.
La programmation informatique fait intégralement partie du monde du Big Data. En effet, plusieurs aspects de la Data Science nécessitent du développement afin d’obtenir la solution parfaite adaptée aux besoins d’une entreprise. Scala et Python font partie des langages les plus utilisés dans ce domaine.
Python met à disposition plusieurs bibliothèques pour la manipulation de données telle que Panda, SciPy et Scikit-Learn. Toutes ces bibliothèques s’appuient sur NumPy. Donc vous voyez que NumPy est incontournable pour un Data scientist.
Dans ce tutoriel exhaustif, nous allons vous apprendre à maîtriser l’analyse des données avec NumPy Python.
Qu’est-ce que NumPy Python ?
NumPy (Numerical Python) est une bibliothèque de python qui comporte des fonctions permettant de manipuler des matrices ou tableaux multidimensionnels.
NumPy est la base de SciPy, qui n’est rien d’autre qu’un ensemble de bibliothèques Python pour des calculs scientifiques. Il est beaucoup plus adapté pour les problématiques qui requièrent l’usage des matrices ou des tableaux multidimensionnels, comme la Data Science, l’ingénierie, les mathématiques ou encore les simulations.
C’est en 2005 que NumPy fut créé par Travis Oliphant. C’est un logiciel open source et compte de nombreux contributeur. NumPy est un projet parrainé financièrement par NumFOCUS.
Pourquoi utiliser NumPy ?
Lors des calculs logiques et mathématiques sur des matrices et tableaux, c’est NumPy qui est très sollicité. Il permet d’effectuer rapidement et efficacement les opérations par rapport aux listes Python.
Les tableaux NumPy utilisent d’abord moins de mémoire et d’espace de stockage, ce qui le rend plus avantageux que les tableaux traditionnels de python.
En effet, un tableau NumPy est de petite taille et ne dépasse pas les 4MB. Mais une liste peut atteindre les 20MB. De plus, les tableaux NumPy sont faciles à manipuler.
Différence entre tableau NumPy et liste Python
Tout le long de cet article, nous allons voir des codes dans le langage Python, vu que NumPy est l’une de ses bibliothèques. Donc, il serait plus pratique que vous ayez les bases nécessaires afin de pouvoir tout suivre. Notre article sur la programmation Python vous aidera à acquérir cette base.
La question à se poser est : pourquoi ne pas utiliser les listes Python qui agissent comme de tableau au lieu d’utiliser les tableaux NumPy ? C’est la manière dont Python stocke un objet dans la mémoire qui répondra au mieux à cette question.
Un objet Python n’est rien d’autre qu’un pointeur, il pointe vers l’emplacement mémoire où vous pouvez trouver toutes les informations sur l’objet comme les octets et la valeur.
Les listes Python sont des tableaux pointeur, qui pointent chacun vers un emplacement qui contient les détails relatifs à l’élément. Cela augmente la surcharge de mémoire et parfois, ces informations se répètent lorsque les objets stockés sont de même type.
C’est pour éviter ce problème qu’il faut utiliser les tableaux NumPy. Ceux-ci prennent des éléments homogènes (des éléments qui ont les mêmes types de données), ce qui facilite la manipulation du tableau.
Cette différence est remarquable quand vous voulez traiter avec des tableaux ayant des milliers d’éléments. De plus, avec les tableaux NumPy, vous serez en mesure d’effectuer des opérations par éléments, ce qui est impossible avec les listes Python.
Voilà la vraie raison pour laquelle les tableaux NumPy sont les plus utilisés par rapport aux listes, pendant les opérations d’une grande quantité de données.
Différence entre NumPy et Pandas
Panda est sous licence BSD et open source. Il est sollicité lorsqu’il faut travailler sur des données tabulaires. Ce langage code dans des langues comme Python, Cython et C. Avec Pandas, les données sont au format JSON, SQL etc. Il propose des objets de table 2D qui sont appelés DataFrame, l’indexation de la série Pandas est lente et consomme plus mémoire.
Voyons cela avec cet exemple :
import pandas as pd
age = [['Aman', 95.5, "Male"], ['Sunny', 65.7, "Female"],
['Monty', 85.1, "Male"], ['toni', 75.4, "Male"]]
df = pd.DataFrame(age, columns=['Name', 'Marks', 'Gender'])
df
Quant à NumPy,c’est une bibliothèque Python utilisée pour travailler sur des données numériques. NumPy permet de créer et de manipuler des tableaux multidimensionnels. Les tableaux NumPy sont rapides, simples à comprendre et les utilisateurs peuvent facilement effectuer des calculs sur ses tableaux. Il occupe peu de mémoire et son indexation des tableaux est très rapide.
Prenons également un exemple pour illustrer cela :
import numpy as np
org_array = np.array([[23, 46, 85],
[43, 56, 99],
[11, 34, 55]])
print(org_array)
Démarrer avec NumPy Python
Installation de NumPy
Si vous avez installé Anaconda, alors NumPy est déjà installé sur votre système. Mais dans le cas contraire, tapez cette ligne de commande dans votre terminal :
pip install numpy Pour utiliser la bibliothèque, il faut l’importer :
import numpy as npnp est juste une abréviation de numpy utiliser par les data scientists.
Manipulation de tableau NumPy
Comment créer un tableau de base NumPy ?
Il est très facile de créer un tableau NumPy, il faut juste utiliser la fonction np.array() pour cela :
np.array([ 1 , 2 , 3 , 4 ])Vous aurez comme sortie :
Ce tableau n’a que des valeurs entières. Vous avez la possibilité de préciser le type de données dans l’argument :
np.array ([ 1 , 2 , 3 , 4 ], dtype = np . float32 )Vous aurez comme sortie :
Mais comme dans les tableaux NumPy, les données sont toutes de même type, alors, NumPy va automatiquement trans-typer les types qui ne correspondent pas.
np.array([ 1 , 2.0 , 3 , 4 ])Ici, ce tableau est constitué des valeurs entières (1,3,4) et décimales (2.0). À la sortie, toutes les valeurs entières passeront à une valeur flottante pour que tout soit homogène.
Les tableaux multidimensionnels NumPy
Tableau de Zéros et de Un
Avec NumPy, vous avez la possibilité de créer des tableaux dont toutes les valeurs sont 0. C’est avec la méthode np.zeros() que vous pouvez effectuer cette opération.
Pour créer le tableau de tous les 1, il faut faire :
np.ones(5,dtype = np . int32 )
Les nombres aléatoires
La méthode la plus utilisée pour créer des tableaux est la méthode np.random.rand(). Cette méthode crée des tableaux avec des valeurs aléatoires comprises entre 0 et 1 :
Un tableau de votre choix
Vous avez la possibilité de remplir le tableau avec n’importe quelle donnée grâce à la méthode np.full() :
Imatrix dans NumPy
Il est possible de créer une matrice identité grâce à la méthode np.eye(). Une matrice identité est une matrice carrée qui a que des 1 sur sa diagonale et 0 partout ailleurs, comme ceci :
Tableaux régulièrement espacés
Les tableaux régulièrement espacés s’obtiennent grâce à la méthode np.arange(). Le but est d’obtenir un tableau avec des valeurs espacées d’un pas régulier. Il faut savoir que l’intervalle est comme ceci : [début, fin] ou le dernier nombre ne sera pas pris.
Si l’on exécute np.arange(2, 12, 3), le tableau aura que des valeurs comprises entre 2 et 12 exclu avec un pas régulier de 3.
La fonction np.linspace() fait aussi presque la même chose, mais au lieu de la taille du pas, elle prend en compte le nombre d’échantillons qui doivent être extraits de l’intervalle. Un point à noter ici est que le dernier nombre est inclus dans les valeurs renvoyées, contrairement au cas de np.arange().
Maintenant, vous savez comment créer un tableau à l’aide de la bibliothèque NumPy mais il est aussi important d’avoir une idée sur la forme du réseau.
La forme et le remodelage des tableaux NumPy
Après avoir créé votre tableau, la tâche suivante est de vérifier le nombre d’axes, la taille et la forme du tableau.
Dimension des tableaux
Pour déterminer le nombre d’axes ou la dimension d’un tableau NumPy, on passe par l’attribut ndims comme suit :
# nombre d’axe
a = np.array([[5,10,15],[20,25,20]])
print('Array :','\n',a)
print('Dimensions :','\n',a.ndim)
Le résultat que l’on obtient à partir de ce bout de code est le suivant :
Vous remarquez que le tableau a 2 dimensions et 3 colonnes.
Forme du tableau NumPy
La forme du tableau NumPy n’est rien d’autre que le nombre de lignes d’éléments sur le long de chaque dimension. Il est possible d’indexer chaque dimension pour obtenir le nombre d’éléments.
a = np . array ([[ 1 , 2 , 3 ],[ 4 , 5 , 6 ]])
print ( 'Array :' , '\n' , a )
print ( 'Forme :' , '\n' , a . shape )
print ( 'Ligne = ' , a . shape [ 0 ])
print ( 'Clonne = ' , a . shape [ 1])
Le résultat sera :
Taille du tableau Numpy
La taille du tableau est la multiplication du nombre de lignes par le nombre de colonnes. Et c’est l’attribut size qui permet de faire cette opération :
# taille du tableau
a = np . array ([[ 5 , 10 , 15 ],[ 20 , 25 , 20 ]])
print('Taille du tableau :',a.size)
print('Détermination manuelle de la taille du tableau :',a.shape[0]*a.shape[1])
Voici ce que l’on obtient :
Comment changer la forme du tableau NumPy ?
Vous pouvez donner une autre forme à votre tableau sans modifier les données qu’il comporte et cela grâce à la méthode np.reschape().
# remodeler
a=np.array([ 3 , 6 , 9 , 12 ])
print ( 'Forme initiale :' , '\n' , a )
np.reshape(a ,( 2 , 2 ))
Comme vous pouvez le constater, la forme initiale était 1 ligne et 3 colonnes et elle est passée de 2 lignes 2 colonnes.
Quand vous voulez changer la forme et que vous n’êtes pas sûr de l’un des axes, mettez simplement -1. NumPy va se charger du reste dès qu’il voit -1 :
a = np . array ([ 3 , 6 , 9 , 12 , 18 , 24 ])
print ( 'Trois lignes :' , '\n' , np . reshape ( a ,( 3 , - 1 )))
print ( 'Trois colonnes :' , '\n' , np . reshape ( a ,( - 1 , 3 )))
Aplatir un tableau NumPy
Il arrive parfois que vous alliez vouloir réduire un tableau multidimensionnel à un tableau à une seule dimension. Pour cela, vous pouvez utiliser les méthodes flatten() et ravel().
a = np.ones((2,2))
b = a.flatten()
c = a.ravel()
print('Forme Original :', a.shape)
print('Array :','\n', a)
print('Forme après aplatissement :',b.shape)
print('Array :','\n', b)
print('Forme après ravel :',c.shape)
print('Array :','\n', c)
Il existe une grande différence entre la flatten() et ravel(). Avec flatten(), on obtient une copie du tableau original alors qu’avec ravel(), on obtient plutôt une référence du tableau original. Cela signifie que toute modification apportée au tableau renvoyé par ravel() sera également reflétée dans le tableau d’origine alors que ce ne sera pas le cas avec flatten().
b[0] = 0
print(a)
Ici, la modification faite n’a pas été reflétée dans le tableau d’origine.
c[0] = 0
print(a)
Quant à ce dernier, la valeur modifiée est apparue dans le tableau original.
L’action produite ici est que ravel crée une copie peu profonde alors que flatten() crée une copie profonde.
On parle de copie profonde lorsqu’un nouveau tableau est créé en mémoire et flatten() envoie un objet tableau qui pointe vers le nouvel emplacement. Ainsi les modifications apportées ne vont pas toucher l’ancien tableau.
Une copie peu profonde ou superficielle renvoie une référence à la position de la mémoire d’origine. Ce qui veut dire que l’objet renvoyé par ravel() pointe vers le même que l’objet tableau d’origine. Donc toute modification du nouveau tableau sera visible sur l’ancien tableau.
Transposition d’un tableau NumPy
Une autre manière de modifier la forme d’un tableau avec NumPy est la méthode transpose(). Cette méthode renvoie la transpose d’un tableau qui est le changement des valeurs des lignes par les colonnes.
a = np.array([[1,2,3],
[4,5,6]])
b = np.transpose(a)
print('Original','\n','Shape',a.shape,'\n',a)
print('Développer le long des colonnes :','\n','Forme',b.shape,'\n',b)
On passe d’un tableau 2X3 à un tableau 3X2. Cette opération est très fréquente en algèbre linéaire.
Extension et compression d’un tableau NumPy Python
Développer un tableau NumPy
Avec la méthode expand_dims(), vous pouvez ajouter un nouvel axe à votre tableau. Il faut juste préciser l’axe :
# etendre la dimensions
a = np.array([1,2,3])
b = np.expand_dims(a,axis=0)
c = np.expand_dims(a,axis=1)
print('Original:','\n','Shape',a.shape,'\n',a)
print('Etendre le long des colonnes:','\n','Shape',b.shape,'\n',b)
print('étendre le long des lignes:','\n','Shape',c.shape,'\n',c)
Compression d’un tableau NumPy
Pour réduire l’axe du tableau, vous pouvez utiliser la méthode squeeze(). Cette méthode effacera l’axe qui a une seule entrée. Par exemple, si vous créez une matrice 2X2X1, squeeze() effacera la troisième dimension de la matrice.
# cOMPRESSER
a = np.array([[[1,2,3],
[4,5,6]]])
b = np.squeeze(a, axis=0)
print('Original','\n','Shape',a.shape,'\n',a)
print('Tableau compressé:','\n','Shape',b.shape,'\n',b)
Par contre, si vous utilisez squeeze sur une matrice 2×2 vous obtiendrez une erreur.
Indexation et découpage du tableau NumPy
Jusqu’à présent, vous avez créé un tableau NumPy et puis jouez avec sa forme. Maintenant, vous découvrirez comment extraire une valeur spécifique du tableau grâce au découpage et à l’indexation.
Découpage de tableaux NumPy 1-D
Ici, le découpage veut dire récupérer des éléments d’un index à un autre. Il faut juste donner le point de départ et d’arrivée de l’index comme ceci : [début : fin].
Vous pouvez même faire mieux en donnant le pas de la taille. Qu’est-ce que c’est ? Comme exemple, disons que vous voulez afficher les éléments d’un tableau avec pas 2. On a [start:end:step-size] :
Vous l’aurez remarqué, le dernier élément n’est pas pris en compte, le découpage ne prend pas le dernier élément de l’index.
Pour éviter ce problème, il faut juste prendre une valeur supérieure à la valeur de l’index final :
S’il arrive que vous ne spécifiez pas l’index de début ou de fin, la valeur par défaut est 0 et 1 pour le pas.
Découpage de tableaux NumPy 2D
Il sera un peu difficile de découper un tableau 2D, car il est composé de lignes et de colonnes. Mais le principe est facile à comprendre et peut être appliqué à n’importe quels autres tableaux de dimension.
Avant de découper un tableau 2D, voyons comment obtenir un élément d’un tableau 2D :
Dans le cas d’un tableau 2-D, vous allez fournir la valeur de la ligne et de la colonne pour retrouver l’élément à extraire. Mais dans le cas d’un tableau 1-D, c’est juste la valeur de la colonne qui est à préciser, car il n’y a qu’une seule ligne.
Voici comment découper un tableau 2-D :
a = np.array([[1,2,3],[4,5,6]])
# affiche les valeurs de la première ligne
print('Valeurs de la première ligne :','\n',a[0:1,:])
# avec un pas pour les colonnes
print('Valeurs alternatives de la première ligne :','\n',a[0:1,::2])
#
print('Valeurs de la deuxième colonne :','\n',a[:,1::2])
print('Valeurs arbitraires :','\n',a[0:1,1:3])
Découpage de tableaux NumPy 3D
Jusqu’à ce niveau, on n’a pas encore parlé de tableau 3-D. Voyons à quoi ressemble un tableau 3-D :
a = np.array([[[1,2],[3,4],[5,6]],# premier axe tableau
[[7,8],[9,10],[11,12]] ,# tableau deuxième axe
[[13,14],[15,16],[17,18]]])# tableau troisième axe
# tableau 3-D
print(a
En plus des lignes et des colonnes, comme le cas de tableau 2D, un tableau 3D a un axe de profondeur où il empile un tableau 2D l’un derrière l’autre.
Donc, en voulant découper un tableau 3D, vous allez d’abord mentionner le tableau 2D que vous découpez. C’est souvent la première valeur de l’index :
a = np.array([[[1,2],[3,4],[5,6]],# first axis array
[[7,8],[9,10],[11,12]],# second axis array
[[13,14],[15,16],[17,18]]])# third axis array
# valeur
print('Premier tableau, première ligne, valeur de la première colonne :','\n',a[0,0,0])
print('Premier tableau dernière colonne :','\n',a[0,:,1])
print('Deux premières lignes pour les deuxième et troisième tableaux :','\n',a[1:,0:2,0:2])
Voici le résultat obtenu :
Si vous souhaitez travailler avec des valeurs sous la forme d’un tableau à une dimension, utiliser la méthode flatten() :
Découpage négatif des tableaux NumPy
Encore une autre manière intéressante de découper votre tableau est de passer par le découpage négatif. Voilà comment ça se passe :
a = np.array([[1,2,3,4,5],
[6,7,8,9,10]])
print(a[:,-1])
Vous avez remarqué que c’est juste les dernières valeurs de chaque ligne qui est affichée. Maintenant, si vous voulez extraire les deux dernières valeurs, voilà ce qu’il faut faire :
a = np.array([[1,2,3,4,5],
[6,7,8,9,10]])
print(a[:,-1:-3:-1])
C’est la même logique, l’indice de fin ici est -3 et n’est pas pris en compte dans la sortie.
Une utilisation intéressante du découpage négatif est d’inverser complètement le tableau d’origine.
a = np.array([[1,2,3,4,5],
[6,7,8,9,10]])
print('Tableau d"origine :','\n',a)
print('Tableau inversé :','\n',a[::-1,::-1])
Avec la méthode flip(), vous pouvez aussi inverser le tableau :
a = np.array([[1,2,3,4,5],
[6,7,8,9,10]])
print('Tableau inversé verticalement :','\n',np.flip(a,axis=1))
print('Tableau inversé horizontalement :','\n',np.flip(a,axis=0))
Empiler et concaténer des tableaux NumPy
Empiler des tableaux
Il existe deux manières de créer un tableau en combinant d’autres tableaux. Vous allez découvrir les deux manières :
- Combiner les tableaux sur la verticale, c’est à dire le long des lignes grâce à la méthode vstack(). Cela va augmenter évidemment le nombre de lignes dans le tableau final ;
- Effectuer une combinaison sur l’horizontal, c’est à dire le long des colonnes grâce à la méthode hstack(). Cela va augmenter évidemment le nombre de colonnes dans le tableau final.
a = np.arange(0,5)
b = np.arange(5,10)
print('Tableau 1 :','\n',a)
print('Tableau 2 :','\n',b)
print('Empilement vertical :','\n',np.vstack((a,b)))
print('Empilement horizontal :','\n',np.hstack((a,b)))
Remarque : Vous devez absolument avoir la même taille sur le long de l’axe sur lequel vous voulez combiner les tableaux, dans le cas échéant vous aurez un message d’erreur :
Une autre manière de créer de tableau en combinant d’autres et d’utiliser la méthode dstch(). Ici, la combinaison se fait index par index et les arrange le long de l’axe de profondeur.
Concaténer des tableaux
Il n’y a pas que la méthode de combinaison qui permet de formuler un tableau à base d’autres tableaux. Avec la méthode concatenate(), le tour est joué :
a = np.arange(0,5).reshape(1,5)
b = np.arange(5,10).reshape(1,5)
print('Tableau 1 :','\n',a)
print('Tableau 2 :','\n',b)
print('Concaténer le long des lignes :','\n',np.concatenate((a,b),axis=0))
print('Concaténer le long des colonnes :','\n',np.concatenate((a,b),axis=1))
Le défaut dans cette méthode est que le tableau d’origine doit nécessairement avoir l’axe le long duquel vous souhaitez faire la combinaison. Sinon il y a une erreur.
Il y a également la méthode append() quiajoute plutôt de nouvel élément dans le tableau :
# ajoute des valeurs à ndarray
a = np.array([[1,2],
[3,4]])
np.append(a,[[5,6]], axis=0)
Diffusion dans les tableaux NumPy Python – Une classe à part !
La diffusion fait partie des meilleures fonctionnalités de tableau. Vous pouvez effectuer des opérations arithmétiques entre des tableaux de dimensions différentes ou un nombre simple et un tableau.
a = np.arange(10,20,2)
b = np.array([[2],[2]])
print('Ajout de deux tableaux de tailles différentes :','\n',a+b)
print('Multiplication d un tableau et d un nombre :',a*2)
La diffusion modifie la taille du petit tableau pour qu’elle soit égale à celui du grand tableau.
NumPy Ufuncs – Le secret de son succès !
Python est un langage dynamique. Ce qui veut dire que lors d’une affectation, Python n’a pas besoin de connaître le type de donnée de la variable. Il le détermine automatiquement lors de l’exécution et cela ralentit Python malgré que son code soit propre et facile à écrire.
On rencontre ce problème lorsque Python opère plusieurs opérations en boucle, comme l’ajout des deux tableaux. En effet, pour chaque opération effectuée, Python doit déterminer le type de donnée de tous les éléments. Mais ce problème est résolu par NumPy grâce à la fonction Unfuncs.
NumPy utilise la vectorisation pour pouvoir accélérer ce travail. La vectorisation fait la même opération sur élément par élément d’un tableau dans un code compilé. Les types des éléments n’ont pas besoin d’être déterminés à chaque fois et c’est ce qui accélère les opérations.
Unfuncs sont des fonctions universelles dans NumPy Python qui sont juste des fonctions mathématiques. Ces fonctions sont automatiquement appelées lorsque vous faites des opérations mathématiques.
Par exemple, en faisant la somme de deux tableaux, la fonction add() est systématiquement appelée en arrière-plan et effectue le travail.
a = [1,2,3,4,5]
b = [6,7,8,9,10]
%timeit a+b
a = np.arange(1,6)
b = np.arange(6,11)
%timeit a+b
Vous pouvez le constater, la même opération a été effectuée en moins de temps avec NumPy Unfuncs.
Mathématique avec les tableaux NumPy
Voici quelques opérations importantes que vous devez connaître.
Opérations arithmétiques de base sur les tableaux NumPy
Les opérations arithmétiques de base sont faciles à effectuer sur les tableaux NumPy :
a = np.arange(1,6)
print('Soustraire :',a-5)
print('Multiplier :',a*5)
print('Diviser :',a/5)
print('Puissance :',a**2)
print('Reste :',a%5)
Moyenne, médiane et écart type
On obtient la moyenne et l’écart type d’un tableau NumPy grâce à la méthode Mean(), std() et median() :
a = np.arange(5,15,2)
print('Mean :',np.mean(a))
print('Déviation standard :',np.std(a))
print('Median :',np.median(a))
Valeurs Min-Max et leur indice
Les valeurs Min et Max dans un tableau peuvent être trouvés grâce à la méthode min() et max() :
a = np.array([[1,6],
[4,3]])
# minimum le long d'une colonne
print('Min :',np.min(a,axis=0))
# maximum le long d'une ligne
print('Max :',np.max(a,axis=1))
Vous pouvez obtenir facilement l’index de la valeur minimale ou maximale dans le tableau le long d’un axe particulier à l’aide des méthodes argmin() et argmax():
a = np.array([[1,6,5],
[4,3,7]])
# minimum le long d'une colonne
print('Min :',np.argmin(a,axis=0))
# maximum le long d'une ligne
print('Max :',np.argmax(a,axis=1))
Tri dans les tableaux NumPy
La complexité d’un algorithme est primordiale pour tout programmeur. Le tri est une opération basique utilisée au quotidien par les data scientists. Alors, ce sera mieux d’utiliser un bon algorithme de tri avec une complexité temporelle minimale.
La bibliothèque NumPy est une légende quand il s’agit de trier les éléments d’un tableau. Vous pouvez retrouver toute une gamme de fonctions de tri de votre choix :
a = np.array([1,4,2,5,3,6,8,7,9])
np.sort(a, kind='quicksort')
Vous pouvez aussi effectuer le tri le long de l’axe de votre choix :
a = np . array ( [[ 5 , 6 , 7 , 4 ],
[ 9 , 2 , 3 , 7 ]] ) # trier le long de la colonne
print ( 'Trier le long de la colonne :' , '\n' , np . sort ( a , kind = 'mergresort' , axis = 1 ))
# trier le long la ligne
print ( 'Trier le long de la ligne :' , '\n' , np . sort ( a , kind = 'mergesort' , axis =0 ))
Tableau et Image NumPy Python
Les images ne sont rien d’autre qu’un tableau dont les éléments sont appelés des pixels. Les pixels ont une valeur comprise entre 0 et 255. Donc les tableaux NumPy de Python sont utilisés pour stocker et manipuler des données d’images.
Voici une image qu’on peut manipuler :
L’image sera lue sous forme d’un tableau grâce à la méthode Image.open() qui se trouve dans la bibliothèque PIL.
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
# lecture d'image
Image = Image.open( "C:/Users/DJAMELA KELIE/Desktop/image.jpg" )
image_array = np.array( Image )
plt.imshow( image_array )
plt.show()
Pour voir cette image sous la forme d’un tableau, il faut juste taper :
image_array
Il est possible de vérifier la forme, le type et la taille du tableau :
print( 'classe :', type(image_array) )
print( 'type :', image_array.dtype )
print( 'taille :', image_array.shape )
Maintenant qu’on a les données de l’image sous forme de tableau, on peut facilement manipuler l’image à l’aide des fonctions de tableau. Par exemple, vous pouvez retourner l’image horizontalement grâce à la fonction flip() :
plt.imshow( np.flip(image_array, axis=1) )
plt.show()
Voilà, vous avez découvert beaucoup de fonctionnalités dans cet article. Vous connaissez déjà bien l’utilisation des tableaux NumPy et vous êtes prêts à manipuler toutes les données possibles.
Si vous souhaitez découvrir le langage Scala que nous avons mentionné dans l’introduction de cet article, nous vous invitons à télécharger la mini-formation sur ce langage.
