contenu de ce notebook (sauter si déjà acquis) ¶ avoir une intuition de ce qui se passe dans en mémoire pour un numpy.ndarray
An array object represents a multidimensional, homogeneous array of fixed-size items.
indiçage des tableaux numpy modification de la taille des tableaux numpy avec numpy.resize et numpy.reshape (la mémoire sous-jacente est partagée) indirection versus décalage (offset ) organisation de la mémoire ¶ pour prendre des décisions en connaissance de cause
savoir les conséquences de vos choix comprendre les erreurs pour ne pas être dépourvu le jour où votre code, en se complexifiant
devient beaucoup trop lent prend beaucoup trop d’espace mémoire pour vous familiariser avec l’informatique et comprendre
les mécanismes sous-jacents les choix des concepteurs pour vous faire une petite culture en informatique technique
ne jamais penser que c’est magique, incompréhensible, trop compliqué... le plus souvent c’est simplement logique créons un tableau numpy en 2 dimensions: 4 lignes et 5 colonnes
mat = np.array(
[[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
matarray([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
la mémoire occupée en mémoire en nombre d’octets (byte)
organisation en mémoire des tableaux ¶ l’aide (accessible via help(np.ndarray)) dit
An array object represents a multidimensional, homogeneous array of fixed-size items.
donc un numpy.ndarray est un tableau
multi-dimensionnel avec un type d’élément homogène et des éléments de taille fixe homogène
toutes les cases du tableau ont le même type donc elles occupent la même taille en mémoire taille fixe
une fois un tableau créé, on ne peut plus modifier la taille de ses éléments
si on manipule et que la taille des éléments ne suffit plus ?numpy convertit la valeur
pour modifier la taille des éléments ?
pourquoi ces contraintes ?
pour que numpy soit le plus rapide possible dans ses manipulations de tableaux grâce à ces contraintes, passer d’une case du tableau à une autre est très rapide rapidité des manipulations mémoire ¶ offset ¶ supposons que le tableau soit représenté en mémoire par un bloc d’octets continu contiguës et de même taille - homogène)
passer d’une case à une autre devient un simple décalage mémoireon va 2 cases plus loin
l’offset est la distance qui sépare ces deux cases
un tel décalage devient impossible si un tableau était réparti un peu partout en mémoire...
...☐.......☐..☐....☐...
☐....☐.....☐.....☐.....
......☐.....pas d’indirection mémoire ¶ pour un tableau, on sait maintenant
que la taille des éléments est homogène que le bloc est contigu en mémoire ☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐l’idée de n’avoir pas d’indirection est
quand on arrive dans une case du tableau elle contient la valeur qu’on cherche on n’a pas besoin d’aller ailleurs en mémoire Que pourrait-il y avoir d’autre dans une case que la valeur d’un élément ?
si toutes les cases d’un même tableau en informatique ont la même taille, comment puis-je
y “mettre ” des élément hétérogènes ? entier, réel, string... modifier ces éléments sans réallouer le tableau ? tab = [1, np.pi, True ]
tab[0] = 12345678235234501256848345678901234567890264378034
tab[0] = "bonjour"en python, dans une case d’un vecteur (list)
on ne trouve pas l’objet lui même (1 ou "bonjour") mais l’adresse en mémoire de l’endroit où l’objet a été alloué si un tableau contient les adresses de ses éléments
exercice: tableau de chaînes de caractères ¶ exercices
à partir de la liste Python de chaînes de caractères l = ['un', 'deux', 'trois', 'cinq']créez un tableau numpy.ndarray (de nom tab) et affichez-le
modifiez le premier élément pour mettre quatre et affichez le tableau
Que constatez-vous ? Pourquoi quatr ?
affichez le type des éléments, le comprenez-vous ?< est une histoire d’ordre des octets dans les objetsU signifie unicode5 ?
numpy cherche le plus petit type pour stocker les chaînes de caractères initiales
ici une case est constituée d’un tableau d’au plus 5 caractères
exercice: tableau hétérogène ¶ exercice
créez un tableau np.ndarray à partir de la liste Python suivante l = [127, 128, 17.4, np.pi, True, False]affichez le type des élémentsnumpy a trouvé le plus petit type pouvant contenir tous ces objets numériques
ajoutez à la liste Python l, la chaîne de caractères bonjournumpy.ndarray à partir de la nouvelle valeur de l
affichez les éléments
quel type numpy a-t-il trouvé pour stocker tous ces éléments ?
Pour plus d’informations, voir https://
index des tableaux ¶ la mémoire d’un numpy.ndarray est toujours un segment unidimensionnel continu de cases de même taille et même type
☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐numpy crée sur cette base, un système d’indexation
pour considérer le tableau sous une forme (shape) multi-dimensionnelle 1-dimension ¶ créons un tableau de dimension 1 donc de shape=(30,)
seg = np.ones(shape=(30,))un seul index suffit à le parcourir
☐☐☐☐☐☐☐☐☐☐☐☑☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐☐
↑
seg[i]l’index est l’offset à partir du premier élément du tableau
le premier élément du tableau est indiqué par seg0
voila pourquoi la plupart du temps en informatique, les tableaux commencent à l’index 0
(et pas 1, sauf pour matlab , R , Fortran ...)
2-dimension ¶ créons un tableau de dimension 2, par exemple de shape=(3, 10)
seg = np.ones(shape=(3, 10))il faut 2 index pour le parcourirseg[i, j]
j
☐☐☐☐☐☐☐☐☐☐
i ☐☐☐☐☐☑☐☐☐☐
☐☐☐☐☐☐☐☐☐☐avec i ∈ [ 0..3 [ i \in [0..3[ i ∈ [ 0..3 [ j ∈ [ 0..10 [ j \in [0..10[ j ∈ [ 0..10 [
3-dimension ¶ créons un tableau de dimension 3, par exemple de shape=(2, 3, 10)
seg = np.ones(shape=(2, 3, 10))3 index pour le parcourir seg[i, j, k]
k
☐☐☐☐☐☐☐☐☐☐
j ☐☐☐☐☐☑☐☐☐☐
☐☐☐☐☐☐☐☐☐☐
i
☐☐☐☐☐☐☐☐☐☐
☐☐☐☐☐☐☐☐☐☐
☐☐☐☐☐☐☐☐☐☐avec i ∈ [ 0..2 [ i \in [0..2[ i ∈ [ 0..2 [ j ∈ [ 0..3 [ j \in [0..3[ j ∈ [ 0..3 [ k ∈ [ 0..10 [ k \in [0..10[ k ∈ [ 0..10 [
et ainsi de suite
les lignes et colonnes ¶ fonctions resize et reshape ¶ on peut modifier la forme d’un numpy.ndarray existant
deux fonctions pour réindexer un tableau: ndarray.reshape et ndarray.resize
reshape
seg = np.arange(0, 30)
seg = seg.reshape(5, 6) # reshape retourne le tableau ainsi modifié
seg = seg.reshape(2, 5, 3)on peut le faire dès la création du tableau
l = range(30)
seg = np.array(l).reshape(2, 5, 3)resize
seg = np.arange(0, 30)
seg.resize(5, 6) # resize modifie le tabeau en place
seg.resize(2, 5, 3)si aucune mémoire n’est créée, c’est que les différentes indexations prises sur un tableaupartagent l’objet sous-jacent
# le code
seg = np.arange(0, 30)
seg = seg.reshape(5, 6) # reshape retourne le tableau ainsi modifié
print(seg)
seg = seg.reshape(2, 5, 3)
print(seg)[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]
[24 25 26 27 28 29]]
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
[12 13 14]]
[[15 16 17]
[18 19 20]
[21 22 23]
[24 25 26]
[27 28 29]]]
# le code
seg = np.arange(0, 30)
seg.resize(5, 6) # resize modifie le tabeau en place
print(seg)
seg.resize(2, 5, 3)
print(seg)[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]
[24 25 26 27 28 29]]
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
[12 13 14]]
[[15 16 17]
[18 19 20]
[21 22 23]
[24 25 26]
[27 28 29]]]
mémoire partagée ¶ exercice
créez un tableau tab de 6 ones de forme (6)
mettez dans tab1 le reshape de tab avec la forme (3, 2)
modifiez le premier élément de tab
affichez tab1
les deux objets tab et tab1 de type numpy.ndarray
sont des objets différents (leurs index sont différents) mais ils ont le même segment sous-jacent de données toucher l’un a pour effet de modifier l’autre indice pour créer un tuple de dimension 1
si vous écrivez (1) dans un programme Python, les parenthèses sont interprétées comme dans un calcul, i.e. comme dans (2+3), du coup le résultat c’est l’entier 1tuple qui ne contient que un élément, je vous recommande d’écrire (1,)