1.4.1.
L'objet tableau NumPy
Contenu de la section
Que sont NumPy et les tableaux NumPy ?
Création de tableaux
Types de données de base
Visualisation de base
Indexation et découpage
Copies et vues
Indexation sophistiquée
[Link]. Que sont NumPy et les tableaux NumPy ?
Tableaux NumPy
Objets objets numériques de haut niveau : entiers, virgule flottante
Python : conteneurs : listes (insertion et ajout gratuits), dictionnaires (re-
cherche rapide)
NumPy fournit package d'extension Python pour les tableaux multidimensionnels
: plus proche du matériel (efficacité)
conçu pour le calcul scientifique (commodité)
Également connu sous le nom de calcul orienté tableau
>>>
>>> import numpy as np
>>> a = [Link]([0, 1, 2, 3])
>>> a
array([0, 1, 2, 3])
Par exemple, un tableau contenant :
valeurs d'une expérience/simulation à des pas de temps discrets
signal enregistré par un appareil de mesure, par exemple une onde sonore
pixels d'une image, niveau de gris ou couleur
Données 3D mesurées à différentes positions XYZ, par exemple une IRM
…
Pourquoi c'est utile : Conteneur économe en mémoire qui fournit des opérations numé-
riques rapides.
In [1]: L = range(1000)
In [2]: %timeit [i**2 for i in L]
1000 loops, best of 3: 403 us per loop
In [3]: a = [Link](1000)
In [4]: %timeit a**2
100000 loops, best of 3: 12.7 us per loop
Documentation de référence NumPy
Sur le Web : [Link]
Aide interactive :
In [5]: [Link]?
String Form:<built-in function array>
Docstring:
array(object, dtype=None, copy=True, order=None,
subok=False, ndmin=0, ...
Je cherche quelque chose :
>>>
>>> [Link]('create array')
Search results for 'create array'
---------------------------------
[Link]
Create an array.
[Link]
Create a memory-map to an array stored in a *binary*
file on disk.
In [6]: [Link]*?
[Link]
[Link]
[Link]
[Link]
Conventions d'importation
La convention recommandée pour importer numpy est :
>>>
>>> import numpy as np
[Link]. Création de tableaux
Construction manuelle de tableaux
1-D :
>>>
>>> a = [Link]([0, 1, 2, 3])
>>> a
array([0, 1, 2, 3])
>>> [Link]
1
>>> [Link]
(4,)
>>> len(a)
4
2D, 3D, … :
>>>
>>> b = [Link]([[0, 1, 2], [3, 4, 5]]) # 2 x 3 ar-
ray
>>> b
array([[0, 1, 2],
[3, 4, 5]])
>>> [Link]
2
>>> [Link]
(2, 3)
>>> len(b) # returns the size of the first dimension
2
>>> c = [Link]([[[1], [2]], [[3], [4]]])
>>> c
array([[[1],
[2]],
[[3],
[4]]])
>>> [Link]
(2, 2, 1)
Exercice : Tableaux simples
Créez un tableau simple à deux dimensions. Commencez par reproduire les
exemples ci-dessus. Puis créez le vôtre : pourquoi ne pas compter les nombres
impairs à rebours sur la première ligne, et les nombres pairs sur la seconde ?
Utilisez les fonctions len() , [Link]() sur ces tableaux. Quel est leur
lien entre elles ? Et avec l' ndimattribut des tableaux ?
Fonctions pour créer des tableaux
En pratique, nous saisissons rarement les éléments un par un…
Régulièrement espacés :
>>>
>>> a = [Link](10) # 0 .. n-1 (!)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = [Link](1, 9, 2) # start, end (exclusive),
step
>>> b
array([1, 3, 5, 7])
ou par nombre de points :
>>> c = [Link](0, 1, 6) # start, end, num-points>>>
>>> c
array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])
>>> d = [Link](0, 1, 5, endpoint=False)
>>> d
array([0. , 0.2, 0.4, 0.6, 0.8])
Tableaux communs :
>>>
>>> a = [Link]((3, 3)) # reminder: (3, 3) is a tuple
>>> a
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
>>> b = [Link]((2, 2))
>>> b
array([[0., 0.],
[0., 0.]])
>>> c = [Link](3)
>>> c
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
>>> d = [Link]([Link]([1, 2, 3, 4]))
>>> d
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
[Link] : nombres aléatoires (Mersenne Twister PRNG) :
>>>
>>> a = [Link](4) # uniform in [0, 1]
>>> a
array([ 0.95799151, 0.14222247, 0.08777354,
0.51887998])
>>> b = [Link](4) # Gaussian
>>> b
array([ 0.37544699, -0.11425369, -0.47616538,
1.79664113])
>>> [Link](1234) # Setting the random
seed
Exercice : Création de tableaux à l'aide de fonctions
Expérimentez avec arange, linspace, ones, zeros, eyeet diag.
Créez différents types de tableaux avec des nombres aléatoires.
Essayez de définir la graine avant de créer un tableau avec des valeurs aléatoires.
Regardez la fonction [Link]. À quoi sert-elle ? Quand est-ce que cela peut
être utile ?
[Link]. Types de données de base
Vous avez peut-être remarqué que, dans certains cas, les éléments d'un tableau sont affi-
chés avec un point final (par exemple 2., vs 2). Cela est dû à une différence de type de
données utilisé :
>>>
>>> a = [Link]([1, 2, 3])
>>> [Link]
dtype('int64')
>>> b = [Link]([1., 2., 3.])
>>> [Link]
dtype('float64')
Différents types de données permettent de stocker les données de manière plus compacte
en mémoire, mais la plupart du temps, nous travaillons simplement avec des nombres à virgule
flottante. Notez que, dans l'exemple ci-dessus, NumPy détecte automatiquement le type de
données à partir de l'entrée.
Vous pouvez spécifier explicitement le type de données que vous souhaitez :
>>>
>>> c = [Link]([1, 2, 3], dtype=float)
>>> [Link]
dtype('float64')
Le type de données par défaut est à virgule flottante :
>>>
>>> a = [Link]((3, 3))
>>> [Link]
dtype('float64')
Il existe également d’autres types :
Complexe: >>>
>>> d = [Link]([1+2j, 3+4j, 5+6*1j])
>>> [Link]
dtype('complex128')
Booléen : >>>
>>> e = [Link]([True, False, False, True])
>>> [Link]
dtype('bool')
Cordes : >>>
>>> f = [Link](['Bonjour', 'Hello', 'Hallo'])
>>> [Link] # <--- strings containing max.
7 letters
dtype('S7')
Bien plus int32
encore : int64
uint32
uint64
[Link]. Visualisation de base
Maintenant que nous avons nos premiers tableaux de données, nous allons les visualiser.
Commencez par lancer IPython :
$ ipython # or ipython3 depending on your install
Ou le carnet :
$ jupyter notebook
Une fois IPython démarré, activez les tracés interactifs :
>>>
>>> %matplotlib
Ou, à partir du bloc-notes, activez les tracés dans le bloc-notes :
>>>
>>> %matplotlib inline
Il inlineest important pour le notebook que les tracés soient affichés dans le notebook
et non dans une nouvelle fenêtre.
Matplotlib est un package de traçage 2D. Nous pouvons importer ses fonctions comme
suit :
>>>
>>> import [Link] as plt # the tidy way
Et puis utilisez (notez que vous devez utiliser showexplicitement si vous n'avez pas activé
les tracés interactifs avec %matplotlib) :
>>>
>>> [Link](x, y) # line plot
>>> [Link]() # <-- shows the plot (not needed
with interactive plots)
Ou, si vous avez activé les tracés interactifs avec %matplotlib:
>>>
>>> [Link](x, y) # line plot
Tracé 1D :
>>>
>>> x = [Link](0, 3, 20)
>>> y = [Link](0, 9, 20)
>>> [Link](x, y) # line plot
[<[Link].Line2D object at ...>]
>>> [Link](x, y, 'o') # dot plot
[<[Link].Line2D object at ...>]
Tableaux 2D (tels que des images) :
>>>
>>> image = [Link](30, 30)
>>> [Link](image, cmap=[Link])
<[Link] object at ...>
>>> [Link]()
<[Link] object at ...>
Voir aussi: Plus d'informations dans le chapitre : matplotlib
Exercice : Visualisations simples
Tracez quelques tableaux simples : un cosinus en fonction du temps et une ma-
trice 2D.
Essayez d'utiliser la graycarte des couleurs sur la matrice 2D.
[Link]. Indexation et découpage
Les éléments d'un tableau peuvent être consultés et assignés de la même manière que les
autres séquences Python (par exemple les listes) :
>>>
>>> a = [Link](10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a[0], a[2], a[-1]
(0, 2, 9)
Les indices commencent à 0, comme les autres séquences Python (et C/C++). En re-
vanche, en Fortran ou Matlab, les indices commencent à 1.
L'idiome Python habituel pour inverser une séquence est pris en charge :
>>>
>>> a[::-1]
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
Pour les tableaux multidimensionnels, les indices sont des tuples d'entiers :
>>>
>>> a = [Link]([Link](3))
>>> a
array([[0, 0, 0],
[0, 1, 0],
[0, 0, 2]])
>>> a[1, 1]
1
>>> a[2, 1] = 10 # third line, second column
>>> a
array([[ 0, 0, 0],
[ 0, 1, 0],
[ 0, 10, 2]])
>>> a[1]
array([0, 1, 0])
Note:
En 2D, la première dimension correspond aux lignes , la seconde aux colonnes .
pour multidimensionnel a, a[0]est interprété en prenant tous les éléments dans
les dimensions non spécifiées.
Découpage : les tableaux, comme les autres séquences Python, peuvent également être dé-
coupés :
>>>
>>> a = [Link](10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a[2:9:3] # [start:end:step]
array([2, 5, 8])
Notez que le dernier index n'est pas inclus ! :
>>>
>>> a[:4]
array([0, 1, 2, 3])
Les trois composants de tranche ne sont pas obligatoires : par défaut, le début est 0, la fin
est la dernière et l'étape est 1 :
>>>
>>> a[1:3]
array([1, 2])
>>> a[::2]
array([0, 2, 4, 6, 8])
>>> a[3:]
array([3, 4, 5, 6, 7, 8, 9])
Un petit résumé illustré de l'indexation et du découpage NumPy…
Vous pouvez également combiner l'affectation et le découpage :
>>>
>>> a = [Link](10)
>>> a[5:] = 10
>>> a
array([ 0, 1, 2, 3, 4, 10, 10, 10, 10, 10])
>>> b = [Link](5)
>>> a[5:] = b[::-1]
>>> a
array([0, 1, 2, 3, 4, 4, 3, 2, 1, 0])
Exercice : Indexation et découpage
Essayez les différentes variantes de découpage en utilisant start, endet
step: en partant d'un espace linéaire, essayez d'obtenir des nombres impairs en
comptant à rebours et des nombres pairs en comptant à l'avance.
Reproduisez les tranches du diagramme ci-dessus. Vous pouvez utiliser l'expres-
sion suivante pour créer le tableau :
>>>
>>> [Link](6) + [Link](0, 51, 10)[:, [Link]]
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[30, 31, 32, 33, 34, 35],
[40, 41, 42, 43, 44, 45],
[50, 51, 52, 53, 54, 55]])
Exercice : création d'un tableau
Créez les tableaux suivants (avec les types de données corrects) :
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 2],
[1, 6, 1, 1]]
[[0., 0., 0., 0., 0.],
[2., 0., 0., 0., 0.],
[0., 3., 0., 0., 0.],
[0., 0., 4., 0., 0.],
[0., 0., 0., 5., 0.],
[0., 0., 0., 0., 6.]]
Par sur le parcours : 3 affirmations pour chaque
Astuce : les éléments individuels du tableau sont accessibles de la même manière qu'une
liste, par exemple a[1]ou .a[1, 2]
Astuce : examinez la docstring pour diag.
Exercice : Tuilage pour la création de tableaux
Parcourez la documentation de [Link] utilisez cette fonction pour construire le
tableau :
[[4, 3, 4, 3, 4, 3],
[2, 1, 2, 1, 2, 1],
[4, 3, 4, 3, 4, 3],
[2, 1, 2, 1, 2, 1]]
[Link]. Copies et vues
Une opération de découpage crée une vue sur le tableau d'origine, ce qui permet simple-
ment d'accéder aux données du tableau. Ainsi, le tableau d'origine n'est pas copié en mé-
moire. Vous pouvez l'utiliser np.may_share_memory()pour vérifier si deux tableaux
partagent le même bloc mémoire. Notez cependant que cette opération utilise des heuris-
tiques et peut générer des faux positifs.
Lors de la modification de la vue, le tableau d'origine est également modifié :
>>>
>>> a = [Link](10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = a[::2]
>>> b
array([0, 2, 4, 6, 8])
>>> np.may_share_memory(a, b)
True
>>> b[0] = 12
>>> b
array([12, 2, 4, 6, 8])
>>> a # (!)
array([12, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a = [Link](10)
>>> c = a[::2].copy() # force a copy
>>> c[0] = 12
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.may_share_memory(a, c)
False
Ce comportement peut surprendre à première vue… mais il permet de gagner à la fois de
la mémoire et du temps.
Exemple concret : crible de nombres premiers
Calculer les nombres premiers de 0 à 99, avec un tamis
Construisez un tableau booléen de forme (100,) is_prime, rempli avec True au
début :
>>>
>>> is_prime = [Link]((100,), dtype=bool)
Rayez 0 et 1 qui ne sont pas des nombres premiers :
>>>
>>> is_prime[:2] = 0
Pour chaque entier jà partir de 2, rayez ses multiples supérieurs :
>>>
>>> N_max = int([Link](len(is_prime) - 1))
>>> for j in range(2, N_max + 1):
... is_prime[2*j::j] = False
Parcourez help([Link])et imprimez les nombres premiers
Suivi:
Déplacez le code ci-dessus dans un fichier de script
nomméprime_sieve.py
Exécutez-le pour vérifier qu'il fonctionne
Utiliser l'optimisation suggérée dans le crible d'Eratosthène :
1. Ignorer jceux qui sont déjà connus pour ne pas être des
nombres premiers
2. Le premier numéro à rayer est
[Link]. Indexation sophistiquée
Les tableaux NumPy peuvent être indexés avec des tranches, mais aussi avec des tableaux
de booléens ou d'entiers ( masques ). Cette méthode est appelée indexation sophistiquée . Elle
crée des copies, et non des vues .
Utilisation de masques booléens
>>>
>>> [Link](3)
>>> a = [Link](0, 21, 15)
>>> a
array([10, 3, 8, 0, 19, 10, 11, 9, 10, 6, 0, 20, 12,
7, 14])
>>> (a % 3 == 0)
array([False, True, False, True, False, False, False,
True, False,
True, True, False, True, False, False])
>>> mask = (a % 3 == 0)
>>> extract_from_a = a[mask] # or, a[a%3==0]
>>> extract_from_a # extract a sub-array with the
mask
array([ 3, 0, 9, 6, 0, 12])
L'indexation avec un masque peut être très utile pour attribuer une nouvelle valeur à un
sous-tableau :
>>>
>>> a[a % 3 == 0] = -1
>>> a
array([10, -1, 8, -1, 19, 10, 11, -1, 10, -1, -1, 20, -1,
7, 14])
Indexation avec un tableau d'entiers
>>>
>>> a = [Link](0, 100, 10)
>>> a
array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
L'indexation peut être effectuée avec un tableau d'entiers, où le même index est répété
plusieurs fois :
>>> a[[2, 3, 2, 4, 2]] # note: [2, 3, 2, 4, 2] is a Python >>>
list
array([20, 30, 20, 40, 20])
De nouvelles valeurs peuvent être attribuées avec ce type d'indexation :
>>>
>>> a[[9, 7]] = -100
>>> a
array([ 0, 10, 20, 30, 40, 50, 60, -100, 80,
-100])
Lorsqu'un nouveau tableau est créé par indexation avec un tableau d'entiers, le nouveau ta-
bleau a la même forme que le tableau d'entiers :
>>>
>>> a = [Link](10)
>>> idx = [Link]([[3, 4], [9, 7]])
>>> [Link]
(2, 2)
>>> a[idx]
array([[3, 4],
[9, 7]])
L'image ci-dessous illustre diverses applications d'indexation sophistiquées
Exercice : Indexation de fantaisie
Reproduisez à nouveau l’indexation fantaisie illustrée dans le diagramme ci-
dessus.
Utilisez une indexation sophistiquée à gauche et la création de tableau à droite
pour attribuer des valeurs à un tableau, par exemple en définissant des parties du
tableau dans le diagramme ci-dessus à zéro.