Students Save 30%! Learn & create with unlimited courses & creative assets Students Save 30%! Save Now
Advertisement
  1. Code
  2. Python
Code

Introduction à Numpy

by
Length:MediumLanguages:

French (Français) translation by Stéphane Esteve (you can also view the original English article)

Numeric est un paquet développé à l'origine par Jim Hugunin. C'était l'ancêtre de NumPy, une librairie Python et un projet open-source créé par Travis Oliphant, contraction de Numerical Python. Travis a conçu NumPy en incluant les caractéristiques du paquet Numarray de Numeric.

Le principe fondamental de NumPy est l'apport de tableaux multi-dimensionnels. Aussi, NumPy peut être vu comme la base du calcul matriciel dans Python, et a été conçu dans l'optique de résoudre des problèmes mathématiques et scientifiques. Le module NumPy nous fournit un ensemble de milliers de fonctions mathématiques très utiles, en complément de constantes comme la base logarithmique naturelle (e) et pi (π).

Ce tutorial vous fera découvrir la façon dont on utilise NumPy pour manipuler des tableaux multi-dimensionnels, dont l'objet ndarray, base fondamentale de cette librairie.

Installer NumPy

Parce que Python ne contient pas en lui-même NumPy, la première étape consiste à l'installer. Cette opération s'effectue simplement en saisissant la commande suivante dans votre terminal :

Pour vérifier que NumPy est parfaitement installé sur votre machine, exécutez les commandes suivantes dans l'éditeur IDLE :

Python-IDLE-Numpy

Si la requête d'import s'exécute sans accrocs, alors tout est prêt !

L'objet ndarray

Objet central de NumPy, la ndarray est un tableau à N dimensions, soit une variable contenant une collection d'éléments indexés du même type, selon N entiers (dimension du tableau).

Les attributs principaux de ndarray sont les type de données (dtype), l'allure (shape), la taille (size), la taille de l'élément (itemsize), la donnée (data) et la dimension N (ndim). Apprenons à connaître chacun d'eux à travers un exemple.

Ici, nous allons employer NumPy à la création d'un tableau. Je ne défini aucune dimension de ce tableau ni aucune autre information, à mesure que nous consulterons chacun des attributs pré-cités.

create_array_numpy

Observez la façon dont nous déclarons la fonction array pour créer un tableau. Le résultat de ce script est le suivant :

array_numpy_output

Revenons donc à nos attributs.

dtype

On peut exécuter l'attribut dtype de la manière suivante :

Cette déclaration renvoie un typage de donnée nommé int32. Ça signifie que tous les éléments de ce tableau sont de type int32. J'obtiens ici 32 car j'utilise la version 32-bits de Python. Si vous utilisez une version 64-bits de Python, vous obtiendrez int64. Mais au fond, nous traitons tout ça via des entiers.

Puisque NumPy est dédié au calcul scientifique, il comporte de nombreux types de donnée, tel que le démontre sa documentation. Vous remarquerez que dans sa grande majorité, ils se terminent tous par un nombre, indiquant le nombre de bits associés à ce typage (tel qu'énoncé précédemment).

Les exemples suivants démontrent comment nous pouvons convertir un typage vers un autre :

Les déclarations faites ci-dessus revoient les résultats suivants :

Bien que nous pouvons basculer un typage vers un autre aussi facilement, il est important de noter qu'il est impossible de transformer un nombre complexe en entier ou en décimal.

Allure

L'attribut d'allure renvoie un tuple des dimensions du tableau. Ainsi, la déclaration suivante :

renvoie (4,4), représentant notre tableau sous la forme de 4 lignes et 4 colonnes.

La taille

L'attribut taille renvoie le nombre total d'éléments contenus dans le tableau. Aussi, si nous écrivons :

nous obtenons 16, soit nous avons 16 éléments au sein du tableau.

La taille de l'élément

L'attribut itemsize renvoie la taille d'un seul élément du tableau, sous forme d'octet. La déclaration suivante :

renvoie 4. Ce qui signifie que chaque élément du tableau pèse 4-octets.

La donnée

L'attribut data est un objet Python mis en tampon, provenant du début du tableau de données. Si nous écrivons la ligne suivante :

nous obtenons : <memory at 0x0000021E7E8D7EA0>.

La dimension N

L'attribut ndim renvoie le nombre de dimensions qui définie le tableau. Ainsi, la ligne suivante :

retourne 2, signifiant que le tableau est délimité par deux dimensions.

Après avoir compris les caractéristiques de chaque attribut ndarray, regardons à d'autres exemples d'utilisation de ndarray.

Exemple 1

Imaginons que nous souhaitons créer un nouveau tableau d'un seule ligne et cinq colonnes. Nous le ferions de la manière suivante :

Le résultat de la déclaration ci-dessus est : [1 2 3 4 5].

Exemple 2

Dans cet exemple, je vais ré-écrire le premier exemple, mais en utilisant cette fois les [ ] plutôt que les ( ), de la façon suivante :

numpy_array_square_brackets

Exemple 3

Cet exemple montre comment nous exploitons un typage structuré de données, où nous déclarons à la fois le nom et son typage correspondant :

Si nous faisons print(data_type), nous obtenons :

Nous pouvons employer le height_type à un objet ndarray, de la façon suivante :

Sélectionner des éléments du tableau

Dans cette partie, je vais vous montrer comment on peut sélectionner des éléments spécifiques du tableau. Dans notre tableau tel que défini dans la partie "Objet ndarray", disons que nous souhaitons sélectionner l'élément situé à la troisième ligne et à la quatrième colonne. Nous le ferions de la manière suivante :

Souvenez-vous que l'indexage démarre ici à partie de 0, et c'est la raison pour laquelle nous écrivons [2,3] plutôt que [3,4].

Détails complémentaires sur les tableaux NumPy

Ici, nous continuerons à creuser davantage sur les caractéristiques des tableaux NumPy.

Tableaux Vides (non initialisés)

Nous pouvons créer des tableaux vides via numpy.empty, selon la règle suivante :

Les significations de chacun de ces paramètres dans ce constructeur sont les suivantes :

  • Allure : l'allure (dimensions) du tableau vide.
  • dtype : le typage attendu lors de son rendu, qui est optionnel.
  • Ordre : si vous souhaitez privilégier le tableau de style C (priorité sur la ligne), vous sélectionnez C ; sinon pour un style de tableau orienté FORTRAN (priorité colonne), saisissez plutôt F.

Aussi, créons un tableau vide de [2,2] avec un typage int. C'est possible de cette façon :

Le script ci-dessus renverra les valeurs aléatoires suivantes puisque le tableau n'est pas formaté :

Un tableau rempli de zéros

Pour créer un tableau où tous ses éléments sont zéro, nous utiliserons numpy.zeros. Le constructeur reste identique à numpy.empty, tant par sa syntaxe que ses paramètres. Aussi, pour créer un tableau de zéros d'une dimension de [2,2] et de typage int :

Et le code ci-dessus produit :

De même, un tableau dont tous ses éléments sont des 1 peut parfaitement être déclaré de la même façon, avec numpy.ones.

Des tableaux avec des valeurs réparties équitablement, selon une étendue fixe

Nous pouvons utiliser la fonction numpy.arange pour créer un tableau aux valeurs réparties de façon équitable. Le format du constructeur est le suivant :

Et la définition de chacun de ses paramètres sont :

  • Start : ici commence l'intervalle. Par défaut, sa valeur est 0.
  • Stop : Fin de l'intervalle, qu'il faut déclarer.
  • Step : l'espace entre chaque valeur. Par défaut : 1.
  • dtype : le typage de données en sortie. S'il n'est pas spécifié, son typage sera le même que celui de ses éléments.

Prenons un exemple de numpy.arange.

Le script ci-dessus produit :

Remodelage d'un tableau

Afin de remodeler un tableau, nous utilisons la fonction numpy.reshape. Cette dernière restitue un tableau sous une autre forme sans en changer ses données. Comme on peut le voir dans sa documentation, la fonction est constituée des attributs suivants : numpy.reshape(a, newshape, order='C'), où a représente le tableau à remodeler, newshape l'allure attendue et compatible avec l'allure d'origine, et order est un argument optionnel renvoyant à l'ordre d'indexation que nous voulons pour, à la fois lire le tableau a, et comment nous ré-organisons ses éléments.

C signifie lire/écrire les éléments selon un ordre d'indexation de type C ; F étant l'ordre d'indexation de type Fortran. A devient l'ordre d'indexation de type Fortran pour lire/écrire les éléments si a est un ensemble contigus en mémoire. Sinon, ce sera un ordre d'indexation de type C.

Je reconnais que je parcoure beaucoup de concepts dans ce paragraphe, mais son principe est simple. Prenons notre tableau de départ my_array et remodelons-le. Rappelez-vous que le nouveau tableau (tableau remodelé) doit rester compatible avec le tableau original. Dans ce cas, my_array a l'allure (4,4), contenant donc 16 éléments. Le nouveau tableau doit contenir aussi le même nombre d'éléments.

Nous pouvons reconstruire my_array en lui attribuant huit lignes et deux colonnes, de la façon suivante :

Et à ce moment-là, nous obtenons le résultat suivant, lui aussi constitué de 16 éléments.

Mais que se passe-t-il si nous le remodelons de la façon suivante ?

Et là, vous obtenez l'erreur suivante :

Concaténation de tableaux

Si nous voulons joindre deux ou davantage de tableaux avec la même allure en suivant un axe spécifique, nous pouvons utliser a fonction numpy.concatenate. Sa syntaxe est : numpy.concatenate((a1, a2, ...), axis=0)y.concatenate. a1 et a2 sont des tableaux à l'allure identique, et axis est l'axe sur lequel les tableaux seront mêlés, dont la valeur par défaut est 0.

Encore une fois, prenons un exemple pour mieux illustrer son concept. Dans cet exemple, nous allons joindre (concaténer) trois tableaux.

Et nous obtenons de ce code :

Division de tableaux

A l'opposé de la concaténation de tableaux comme vu précédemment, voyons comment nous pouvons séparer (diviser) un tableau en de multiples sous-tableaux. Faisons-le de cette façon :

ary représente le tableau à diviser en sous-tableaux. Selon la valeur deindices_or_sections, s'il s'agit d'un entier N, le tableau sera découpé en N tableaux de taille égale, le long de son axe. S'il s'agit d'un tableau à une seule dimension, chaque élément constitutif représente un axe où le tableau sera chaque fois découpé. axis détermine l'axe où sera divisé le tableau.

L'exemple qui suit inversera ce que nous obtenons des exemples précédents, soit renvoyer un tableau concaténé avec ses trois tableaux constitutifs :

Et le résultat devient :

Conclusion

Comme on a pu le voir à travers ce tutoriel, NumPy permet une manipulation aisée et flexible des tableaux. Nous n'avons qu'effleurer la surface de cette fabuleuse librairie Python. NumPy contient davantage de caractéristiques à étudier pour sa redoutable efficacité. Il existe aussi un guide complet sur ce sujet par le concepteur de NumPy lui-mêm : Guide to NumPy.

Par ailleurs, je vous invite à consulter notre boutique en ligne pour chercher des documents sur le sujet à étudier ou à acheter. N'hésitez pas non plus à nous contacter pour poser vos questions ou nous laisser vos impressions, via le formulaire ci-dessous.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.