Bien sûr, indexez-le comme vous le feriez normalement. Par exemple, y = x[:k, :]
cela retournera une vue dans le tableau d'origine. Aucune donnée ne sera copiée et toutes les mises à jour effectuées sur y
seront reflétées dans x
et vice versa.
Éditer:
Je travaille généralement avec des matrices 3D> 10 Go d'uint8, donc je m'inquiète beaucoup de cela ... Numpy peut être très efficace dans la gestion de la mémoire si vous gardez quelques choses à l'esprit. Voici quelques conseils pour éviter de faire des copies de tableaux en mémoire:
Utilisez +=
, -=
, *=
, etc pour éviter de faire une copie du tableau. Par exemple x += 10
, modifiera le tableau en place, tandis que x = x + 10
fera une copie et le modifiera. (aussi, jetez un œil à numexpr )
Si vous souhaitez faire une copie avec x = x + 10
, sachez que x = x + 10.0
cela entraînera x
automatiquement une conversion ascendante vers un tableau à virgule flottante, si ce n'était pas déjà le cas. Toutefois, x += 10.0
où x
est un tableau d'entiers, le cast sera 10.0
vers le bas en un entier de la même précision que le tableau.
De plus, de nombreuses fonctions numpy prennent un out
paramètre, vous pouvez donc faire des choses comme np.abs(x, x)
prendre la valeur absolue de x
in-place.
En guise de deuxième modification, voici quelques conseils supplémentaires sur les vues par rapport aux copies avec des tableaux numpy:
Contrairement aux listes python, y = x[:]
ne renvoie pas de copie, il renvoie une vue. Si vous voulez une copie (qui, bien sûr, doublera la quantité de mémoire que vous utilisez) utilisey = x.copy()
Vous entendrez souvent parler d '«indexation sophistiquée» des tableaux numpy. Utiliser une liste (ou un tableau d'entiers) comme index est une "indexation sophistiquée". Cela peut être très utile, mais copie les données.
À titre d'exemple: y = x[[0, 1, 2], :]
renvoie une copie, tandis y = x[:3,:]
que renvoie une vue.
Même une indexation vraiment folle comme l'indexation x[4:100:5, :-10:-1, None]
"normale" et retournera une vue, cependant, n'ayez donc pas peur d'utiliser toutes sortes d'astuces de découpage sur de grands tableaux.
x.astype(<dtype>)
renverra une copie des données en tant que nouveau type, tandis que x.view(<dtype>)
renverra une vue.
Soyez prudent avec cela, cependant ... C'est extrêmement puissant et utile, mais vous devez comprendre comment les données sous-jacentes sont stockées en mémoire. Si vous avez un tableau de flottants et que vous les affichez comme des ints, (ou vice versa) numpy interprétera les bits sous-jacents du tableau comme des ints.
Par exemple, cela signifie qu'en 1.0
tant que flottant 64 bits sur un système little-endian, il sera 4607182418800017408
vu comme un int 64 bits, et un tableau de [ 0, 0, 0, 0, 0, 0, 240, 63]
si vu comme un uint8. C'est vraiment bien quand vous avez besoin de faire un twiddling de bits sur de grands tableaux, cependant ... Vous avez un contrôle de bas niveau sur la façon dont la mémoire tampon est interprétée.
x[np.array([1, 1, 3, 1])] += 1
modifiéx
. Maintenant compris!b
est une vue dea
, alors leb.base is a
seraTrue
. Une copie (de n'importe quel tableau) aura toujoursarr_copy.base is None