Tutoriel sur les tableaux NumPy en Python

Qu’est‑ce qu’un tableau NumPy en Python ?

Vous avez déjà lu en introduction que les tableaux NumPy ressemblent un peu aux listes Python, tout en étant très différents. Pour celles et ceux qui découvrent le sujet, clarifions ce que c’est exactement et à quoi cela sert.

Comme son nom l’indique, un tableau NumPy est une structure de données centrale de la bibliothèque numpy. Le nom est l’abrégé de « Numeric Python » ou « Numerical Python ».

Autrement dit, NumPy est la bibliothèque cœur du calcul scientifique en Python. Elle regroupe des outils et techniques pour résoudre des modèles mathématiques issus des sciences et de l’ingénierie.

Parmi ces outils, on trouve un objet tableau multidimensionnel haute performance, une structure puissante pour des calculs efficaces sur des tableaux et des matrices. Pour travailler avec ces tableaux, une vaste collection de fonctions mathématiques de haut niveau opèrent sur ces matrices et tableaux.

Mais qu’est‑ce qu’un tableau ?

Lorsque vous affichez quelques tableaux, vous pouvez les voir comme une grille contenant des valeurs de même type :

import numpy as np
# Define a 1D array
my_array = np.array([[1, 2, 3, 4],
                     [5, 6, 7, 8]],
                    dtype=np.int64)
# Define a 2D array
my_2d_array = np.array([[1, 2, 3, 4],
                        [5, 6, 7, 8]],
                       dtype=np.int64)
# Define a 3D array
my_3d_array = np.array([[[1, 2, 3, 4],
                         [5, 6, 7, 8]],
                        [[1, 2, 3, 4],
                         [9, 10, 11, 12]]],
                       dtype=np.int64)
# Print the 1D array
print("Printing my_array:")
print(my_array)
# Print the 2D array
print("Printing my_2d_array:")
print(my_2d_array)
# Print the 3D array
print("Printing my_3d_array:")
print(my_3d_array)

Vous voyez que, dans l’exemple ci‑dessus, les données sont des entiers. Le tableau stocke et représente des données régulières de manière structurée.

Notez toutefois que, structurellement, un tableau n’est en réalité qu’un ensemble de pointeurs. C’est une combinaison d’une adresse mémoire, d’un type de données, d’une forme (shape) et de pas (strides) :

• Le pointeur data indique l’adresse mémoire du premier octet du tableau.
• Le type de données (dtype) décrit la nature des éléments contenus dans le tableau.
• La shape indique la forme du tableau.
• Les strides sont le nombre d’octets à sauter en mémoire pour accéder à l’élément suivant. Si vos strides sont (10,1), vous devez avancer d’un octet pour la colonne suivante et de 10 octets pour retrouver la même colonne à la ligne suivante.

En d’autres termes, un tableau contient des informations sur les données brutes, comment localiser un élément et comment l’interpréter.

Assez de théorie. Passons à la pratique :

Vous pouvez tester cela facilement en explorant les attributs d’un tableau numpy :

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print out memory address
print(my_2d_array.data)

# Print out the shape of `my_array`
print(my_2d_array.shape)

# Print out the data type of `my_array`
print(my_2d_array.dtype)

# Print out the stride of `my_array`
print(my_2d_array.strides)

Vous voyez qu’à présent, vous obtenez bien plus d’informations : par exemple, le type de données affiché est « int64 », un entier signé sur 64 bits ; C’est beaucoup plus précis ! Cela signifie aussi que le tableau occupe 64 octets en mémoire (chaque entier prend 8 octets et vous avez un tableau de 8 entiers). Les strides indiquent que vous devez sauter 8 octets (une valeur) pour passer à la colonne suivante, mais 32 octets (4 valeurs) pour retrouver la même position à la ligne suivante. Ainsi, les strides du tableau sont (32,8).

Notez que si vous définissez le type de données sur int32, le tuple de strides renvoyé sera (16, 4), car vous devrez toujours avancer d’une valeur pour la colonne suivante et de 4 valeurs pour la même position à la ligne suivante. La seule différence est que chaque entier occupera 4 octets au lieu de 8.

Le tableau ci‑dessus est, comme son nom l’indique, un tableau à 2 dimensions : des lignes et des colonnes. Les lignes correspondent à « l’axe 0 », les colonnes à « l’axe 1 ». Le numéro d’axe augmente avec le nombre de dimensions : dans des tableaux 3D, comme l’exemple vu plus haut, vous aurez un « axe 2 » supplémentaire. Notez que cette notion d’axes n’a de sens que pour les tableaux d’au moins 2 dimensions : elle ne s’applique pas aux tableaux 1D.

Ces axes vous seront très utiles lorsque vous manipulerez la forme de vos tableaux NumPy.

Comment installer NumPy

Avant de tester vous‑même les tableaux NumPy, assurez‑vous d’avoir installé la bibliothèque en local (en supposant que vous travaillez sur votre ordinateur). Si vous avez déjà Python et NumPy, passez cette section :)

Si vous devez encore préparer votre environnement, sachez qu’il existe deux grandes façons d’installer NumPy sur votre machine : avec les wheels Python ou via la distribution Anaconda.

pip install pip --upgrade
pip --version

pip install numpy-<version>-<architecture>.whl

pip install numpy-1.20.3-cp39-cp39-win_amd64.whl

import numpy

Comment créer des tableaux NumPy

Maintenant que votre environnement est en place, passons aux choses sérieuses. Certes, vous avez déjà essayé quelques opérations sur des tableaux plus haut. Mais vous n’avez pas encore vraiment pratiqué, car il fallait d’abord installer NumPy sur votre machine. C’est fait : voyons comment exécuter vous‑même les extraits de code ci‑dessus.

Pour créer un tableau numpy, utilisez simplement la fonction np.array(). Il suffit de lui passer une liste, et, en option, vous pouvez préciser le type de données. Pour en savoir plus sur les types possibles, consultez ce guide ou jetez un coup d’œil à la feuille de triche NumPy de DataCamp.

Inutile de mémoriser tous les types NumPy si vous débutez, mais vous devez savoir et vous soucier de la nature de vos données. Les types existent pour vous donner un contrôle fin sur le stockage en mémoire et sur disque. Surtout avec de gros volumes, il est utile de maîtriser le type de stockage.

N’oubliez pas que, pour utiliser np.array(), la bibliothèque numpy doit être présente dans votre environnement.

NumPy suit une convention d’import : importez‑la sous l’alias np. Ainsi, les autres Pythonistas comprendront plus facilement votre code.

Dans l’exemple suivant, vous allez créer le tableau my_array que vous avez déjà manipulé plus haut :

import numpy as np

# Make the array `my_array`
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_array`
print(my_array)

Si vous souhaitez en savoir plus sur la création de listes, consultez notre tutoriel sur les listes Python.

Cependant, il arrive que vous ne sachiez pas encore quelles données mettre dans votre tableau, ou que vous vouliez importer des données dans un tableau numpy depuis une autre source. Dans ces cas, vous utiliserez soit des valeurs initiales « tampon », soit des fonctions pour charger des données texte dans des tableaux.

Les sections suivantes vous montrent comment faire.

import numpy as np

# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Create an array of evenly-spaced values
np.linspace(0,2,9)

# This is your data in the text file
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Import your data
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

# Your data in the text file
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

import numpy as np

# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the length of `my_array`
print(len(my_array))

# Change the data type of `my_array`
my_array.astype(float)

Comment fonctionne le broadcasting dans NumPy

Avant d’aller plus loin dans le calcul scientifique, rappelons ce qu’est le broadcasting : c’est un mécanisme qui permet à NumPy de travailler avec des tableaux de formes différentes lors d’opérations arithmétiques.

L’infographie ci‑dessous illustre le broadcasting en action :

Source

Concrètement, vous avez souvent un tableau assez grand et un autre plus petit. Idéalement, vous souhaitez réutiliser le petit tableau pour effectuer une opération (somme, multiplication, etc.) sur le grand.

Pour cela, vous utilisez le mécanisme de broadcasting.

Il y a quelques règles à respecter. Rassurez‑vous, elles sont simples et intuitives !

• D’abord, pour réussir le broadcasting, les dimensions de vos tableaux doivent être compatibles. Deux dimensions sont compatibles lorsqu’elles sont égales. Considérez l’exemple suivant :

# Import the NumPy library and give it an alias of `np`
import numpy as np

# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))

# Print the shape of the array `x`
print("Shape of x:", x.shape)

# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))

# Print the shape of the array `y`
print("Shape of y:", y.shape)

# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)

# Print the shape of the resulting array
print("Shape of x + y:", z.shape)

• Deux dimensions sont aussi compatibles lorsque l’une d’elles vaut 1 :

# Import the NumPy library and give it an alias of `np`
import numpy as np

# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))

# Print the shape of the array `x`
print("Shape of x:", x.shape)

# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))

# Print the shape of the array `y`
print("Shape of y:", y.shape)

# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)

# Print the shape of the resulting array
print("Shape of x + y:", z.shape)

Notez que si les dimensions ne sont pas compatibles, vous obtiendrez une ValueError.

Astuce : testez aussi la taille du tableau obtenu après vos calculs ! Vous verrez qu’elle correspond au maximum le long de chaque dimension parmi les tableaux d’entrée.

Autrement dit, le résultat de x−y donne un tableau de shape (3,4) : y avait une shape (4,) et x (3,4). La taille maximale le long de chaque dimension de x et y est utilisée pour définir la shape du tableau résultant.

• Enfin, les tableaux ne peuvent être diffusés ensemble que s’ils sont compatibles sur toutes les dimensions. Exemple :

# Import `numpy` as `np`
import numpy as np

# Initialize `x` and `y`
x = np.ones((3,4))
y = np.random.random((5,1,4))

# Add `x` and `y`
z = x + y

Vous voyez que, même si x et y ont des dimensions différentes, on peut les additionner.

C’est parce qu’ils sont compatibles sur toutes les dimensions :

• x est de dimension 3 × 4,
• y est de dimension 5 × 1 × 4.

Puisque des dimensions sont compatibles quand l’une vaut 1, ces deux tableaux se prêtent bien au broadcasting !

Vous constaterez que, pour la dimension où y a une taille de 1 et l’autre tableau une taille supérieure (ici 3), le premier se comporte comme s’il était recopié le long de cette dimension.

La shape du résultat sera, là encore, la taille maximale le long de chaque dimension de x et y : (5,3,4).

En bref, pour utiliser le broadcasting, vous vous reposerez beaucoup sur la shape et les dimensions des tableaux avec lesquels vous travaillez.

Et si les dimensions ne sont pas compatibles ?

Si elles ne sont ni égales ni égales à 1 ?

Il faudra corriger cela en manipulant votre tableau ! Vous verrez comment faire un peu plus loin.

Comment fonctionnent les opérations mathématiques sur les tableaux ?

Vous avez vu que le broadcasting est pratique pour les opérations arithmétiques. Dans cette section, découvrez quelques fonctions pour faire des calculs avec des tableaux.

Sans surprise, vous pouvez utiliser +, −, *, / ou % pour additionner, soustraire, multiplier, diviser ou calculer le reste entre deux (ou plusieurs) tableaux. Mais l’un des points forts de NumPy est d’offrir des fonctions dédiées : np.add(), np.subtract(), np.multiply(), np.divide() et np.remainder().

Vous pouvez aussi faire des exponentiations et des racines carrées avec np.exp() et np.sqrt(), ou calculer sinus et cosinus avec np.sin() et np.cos(). Enfin, vous pouvez calculer le logarithme naturel avec np.log() ou le produit scalaire avec dot().

Testez tout cela dans le code ci‑dessous.

Petit conseil : regardez d’abord les tableaux chargés pour l’exercice !

# Import `numpy` as `np`
import numpy as np
x = np.array([[1, 2, 3], [3, 4, 5]])
y = np.array([6,7,8])

# Add `x` and `y`
z = np.add(x,y)
print("Addition of x and y:\n", z)

# Subtract `x` and `y`
z = np.subtract(x,y)
print("Subtraction of y from x:\n", z)

# Multiply `x` and `y`
z = np.multiply(x,y)
print("Element-wise multiplication of x and y:\n", z)

Vous vous souvenez des règles du broadcasting ? Vérifiez les dimensions et la shape de x et y dans votre shell IPython. Les règles sont‑elles respectées ?

Mais ce n’est pas tout.

Voici une courte liste de fonctions d’agrégation :

Au‑delà de ces fonctions, sachez qu’il existe des mécanismes pour comparer des éléments de tableaux. Par exemple, pour vérifier si les éléments de deux tableaux sont égaux, utilisez l’opérateur ==. Pour tester « plus petit » ou « plus grand », utilisez < ou >.

Assez simple, non ?

Vous pouvez également comparer des tableaux entiers entre eux avec np.array_equal(). Il suffit de passer les deux tableaux à comparer, et c’est tout.

Outre la comparaison, vous pouvez effectuer des opérations logiques sur vos tableaux avec np.logical_or(), np.logical_not() et np.logical_and(). Cela fonctionne comme les opérateurs logiques OR, NOT et AND classiques.

Dans l’exemple le plus simple, OR renvoie vrai si l’un des deux éléments vaut 1 (ou si les deux valent 1). AND vérifie si les deux valent 1, NOT inverse les valeurs booléennes.

Testez dans le bloc ci‑dessous :

# Import `numpy` as `np`
import numpy as np
# Initialize arrays
a = np.array([1, 1, 0, 0], dtype=bool)
b = np.array([1, 0, 1, 0], dtype=bool)

# `a` AND `b` 
np.logical_and(a, b)

# `a` OR `b`
np.logical_or(a, b)

# `a` NOT `b`
np.logical_not(a,b)

Comment sous‑sélectionner, slicer et indexer des tableaux

Au‑delà des opérations mathématiques, vous voudrez parfois ne récupérer qu’une partie du tableau (d’origine ou résultant) ou certains éléments pour les utiliser dans d’autres analyses. Dans ce cas, vous aurez besoin de sous‑sélection, de slicing et/ou d’indexation.

Ces opérations ressemblent beaucoup à celles effectuées sur les listes Python. Pour comparer ou pour plus de détails, consultez le tutoriel sur les listes Python de DataCamp.

Si vous n’avez aucune idée de leur fonctionnement, retenez pour l’instant deux points :

• Vous utilisez les crochets [] comme opérateur d’index, et
• Vous y passez généralement des entiers, mais aussi le caractère deux‑points : ou une combinaison de : et d’entiers pour désigner les éléments/lignes/colonnes à sélectionner.

Subsetting

Le plus simple est d’observer quelques exemples de sous‑sélection :

import numpy as np

# Initialize 1D array
my_array = np.array([1,2,3,4])

# Print subsets
print(my_array[1])

import numpy as np

# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print subsets
print(my_2d_array[1][2])
print(my_2d_array[1,2])

import numpy as np

# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Print subset
print(my_3d_array[1,1,2])

Slicing

Un peu plus avancé que la sous‑sélection : le slicing. Ici, vous raisonner au niveau des lignes et des colonnes : vous travaillez avec des « régions » de données plutôt qu’avec de simples « positions ».

Voici ce que cela donne en code :

import numpy as np

# Initialize 1D array
my_array = np.array([1,2,3,4])

# Print subsets
print(my_array[0:2])

import numpy as np

# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print subsets
print(my_2d_array[0:2,1])

import numpy as np

# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Print subset
print(my_3d_array[1,...])

En substance, retenez :

a[start:end] # éléments de start à end (end exclu)
a[start:]    # éléments de start jusqu’à la fin
a[:end]      # éléments du début jusqu’à end (end exclu)

Dans le code ci‑dessus, chaque tableau est initialisé séparément, et des sous‑ensembles sont affichés. my_array, my_2d_array et my_3d_array sont respectivement des tableaux 1D, 2D et 3D, et les sous‑ensembles sont imprimés à l’aide de l’indexation.

Dans le premier exemple, nous sélectionnons les éléments aux index 0 et 1 de my_array. Dans le deuxième, nous sélectionnons les éléments aux lignes 0 et 1, colonne 1 de my_2d_array. Dans le troisième, la notation ... sélectionne tous les éléments le long des première et deuxième dimensions, et le second élément le long de la troisième dimension de my_3d_array.

Indexation

Enfin, NumPy propose l’indexation booléenne et l’indexation avancée (« fancy indexing »).

(Véritable jargon NumPy !)

D’abord l’indexation booléenne : au lieu de sélectionner des éléments, lignes ou colonnes par numéro d’index, vous sélectionnez les valeurs qui satisfont une condition.

En code, c’est très simple :

import numpy as np
my_array = np.array([1,2,3,4])
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Try out a simple example
print(my_array[my_array<2])

# Specify a condition
bigger_than_3 = (my_3d_array >= 3)

# Use the condition to index our 3d array
print(my_3d_array[bigger_than_3])

Pour formuler une condition, vous pouvez aussi utiliser les opérateurs logiques | (OR) et & (AND). Par exemple : bigger_than_3 = (my_3d_array > 3) | (my_3d_array == 3).

Avec les tableaux chargés ici, les possibilités sont limitées, mais avec des tableaux contenant des noms ou des villes, les combinaisons sont infinies !

Pour la fancy indexing, vous passez une liste ou un tableau d’entiers qui spécifie l’ordre du sous‑ensemble de lignes à sélectionner depuis le tableau d’origine.

Un peu abstrait ?

Essayez ci‑dessous :

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Select elements at (1,0), (0,1), (1,2) and (0,0)
print(my_2d_array[[1, 0, 1, 0],[0, 1, 2, 0]])

# Select a subset of the rows and columns
print(my_2d_array[[1, 0, 1, 0]][:,[0,1,2,0]])

La deuxième instruction peut sembler moins intuitive. Décomposons‑la :

• Si vous exécutez simplement my_2d_array[[1,0,1,0]], vous obtenez :

array([[5, 6, 7, 8],
   [1, 2, 3, 4],
   [5, 6, 7, 8],
   [1, 2, 3, 4]])

• La seconde partie, [:,[0,1,2,0]], signifie que vous conservez toutes les lignes de ce résultat, mais vous réorganisez les colonnes : vous affichez les colonnes 0, 1 et 2 telles quelles, puis vous répétez la colonne 0 en dernière position à la place de la colonne 3. Résultat :

array([[5, 6, 7, 5],
   [1, 2, 3, 1],
   [5, 6, 7, 5],
   [1, 2, 3, 1]])

L’indexation avancée n’a plus de secret pour vous !

Comment demander de l’aide

Petite parenthèse : vous pouvez toujours obtenir des informations sur les modules, fonctions ou classes que vous utilisez, surtout qu’au début NumPy peut impressionner.

Demander de l’aide est très simple.

Utilisez les fonctions d’aide spécifiques que propose numpy :

• lookfor() pour rechercher par mot‑clé dans les docstrings. Pratique quand la « théorie » s’estompe. Inconvénient : si la requête est vague, il faut parcourir de nombreux résultats.
• info() pour des explications rapides et des exemples de code sur des fonctions, classes ou modules. Idéal si vous apprenez en pratiquant. Seul bémol : il faut savoir dans quel module se trouve l’attribut ou la fonction. Voyez l’exemple ci‑dessous.

Les deux ont leurs avantages et limites, mais vous verrez vite leur utilité. Essayez :

import numpy as np

# Look up info on `mean` with `np.lookfor()` 
print(np.lookfor("mean"))

# Get info on data types with `np.info()`
np.info(np.ndarray.dtype)

Notez qu’il faut effectivement savoir que dtype est un attribut de ndarray. Et n’oubliez pas de préfixer par np, sinon vous obtiendrez une erreur du type :

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'ndarray' is not defined

Vous savez maintenant comment demander de l’aide, et c’est une excellente chose. Le prochain sujet de ce tutoriel NumPy porte sur la manipulation des tableaux.

Non pas que vous ne puissiez pas l’aborder seul, bien au contraire !

Mais certaines fonctions soulèvent des questions : quelle différence entre redimensionner et remodeler (resize vs reshape) ?

Et entre empiler horizontalement et verticalement ?

La section suivante y répond. Et en cas de doute, utilisez les fonctions d’aide que vous venez de voir.

Comment manipuler des tableaux

Effectuer des opérations mathématiques sur vos tableaux est important, mais, pour que cela — et le broadcasting — fonctionne, vous devez surtout savoir manipuler vos tableaux.

Voici les manipulations les plus courantes.

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array`
print(my_2d_array)

# Transpose `my_2d_array`
print(np.transpose(my_2d_array))

# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)

import numpy as np
my_array = np.array([1,2,3,4])

# Print `my_2d_array
print(my_array)

# Transpose `my_2d_array
print(np.transpose(my_array))

# Or use `T` to transpose `my_2d_array
print(my_array.T)

import numpy as np
x = np.ones((3,4))

# Print the shape of `x`
print(x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x`
print(x)

import numpy as np

# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))

# Print the shape of `x`
print("Shape of x:", x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpose `x`
x = x.T

# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

import numpy as np

my_array = np.array([1,2,3,4])

# Print `my_array` before appending
print("my_array before appending:", my_array)

# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Print `new_array`
print("new_array:", new_array)

# Print `my_array` after appending
print("my_array after appending:", my_array)

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

import numpy as np

my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)

# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Insert `5` at index 1
np.insert(my_array, 1, 5)

# Delete the value at index 1
np.delete(my_array,[1])

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))

# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))

# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])

# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))

# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))

Comment visualiser des tableaux NumPy

Enfin, il est très utile de savoir tracer vos tableaux. C’est précieux en exploration, mais aussi plus tard quand vous souhaitez les visualiser.

# Import `numpy` as `np`
import numpy as np

# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))

# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))

# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')

# Show the plot
plt.show()

# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Create an array
points = np.arange(-5, 5, 0.01)

# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)

# Draw a color bar
plt.colorbar()

# Show the plot
plt.show()

Au‑delà de l’analyse de données avec NumPy

Félicitations, vous êtes arrivé au bout de ce tutoriel NumPy !

Vous avez couvert beaucoup de notions ; veillez maintenant à les ancrer. N’oubliez pas de récupérer la feuille de triche NumPy de DataCamp pour vous y aider !

Après toute cette théorie, place à la pratique. Une option : revenir au tutoriel scikit‑learn et expérimenter davantage avec les tableaux utilisés pour construire des modèles de machine learning.

Si ce n’est pas votre tasse de thé, vérifiez que vous avez bien installé Anaconda. Puis lancez‑vous avec les tableaux NumPy dans Jupyter grâce à ce guide incontournable de Jupyter Notebook. Pensez aussi à consulter ce Jupyter Notebook, qui vous guide dans l’analyse de données en Python avec NumPy et d’autres bibliothèques dans l’environnement interactif de Jupyter.

Enfin, découvrez les cours DataCamp sur la manipulation et la visualisation de données. Nos derniers cours en collaboration avec Continuum Analytics devraient particulièrement vous intéresser ! Parcourez Manipulating DataFrames with Pandas ou Pandas Foundations.