Bien sûr, l'indice de il comme vous le feriez normalement. E. g. y = x[:k, :]
Ce sera le retour de vue dans le tableau d'origine. Pas de données seront copiées, et toutes les mises à jour apportées à l' y
sera reflété dans x
, et vice-versa.
Edit:
J'ai souvent travailler avec >10 GO 3D tableaux de uint8, donc je m'inquiète beaucoup... Numpy peuvent être très efficaces dans la gestion de la mémoire si vous garder quelques choses à l'esprit.
Voici quelques conseils pour éviter de faire des copies de tableaux dans la mémoire:
Utiliser +=
, -=
, *=
, etc pour éviter de faire une copie du tableau. E. g. x += 10
permettra de modifier le tableau en place, alors qu' x = x + 10
va en faire une copie et de le modifier. (aussi, ont un look un numexpr)
Si vous voulez faire une copie avec x = x + 10
, sachez que x = x + 10.0
entraînera x
automatiquement être coulé à virgule flottante de tableau, si ce n'était pas déjà. Toutefois, x += 10.0
où x
est un tableau d'entiers, sera la cause de la 10.0
à la baisse coulé sous pression int de la même précision que dans le tableau, à la place.
En outre, de nombreuses fonctions de numpy prendre un out
paramètre, vous pouvez faire des choses comme np.abs(x, x)
de prendre la valeur absolue de l' x
en place.
Seconde edition, voici quelques conseils sur les points de vue contre les copies avec les tableaux numpy:
Contrairement à python listes, y = x[:]
ne renvoie pas une copie, elle renvoie une vue. Si vous voulez une copie (qui, bien sûr, le double de la quantité de mémoire que vous utilisez) utiliser y = x.copy()
Vous allez souvent entendre parler de "fantaisie d'indexation" des tableaux numpy. À l'aide d'une liste (ou un tableau d'entiers) comme un indice est "envie d'indexation". Il peut être très utile, mais des copies des données.
Un exemple de ceci: y = x[[0, 1, 2], :]
renvoie une copie, alors que y = x[:3,:]
serait de retour d'une vue.
Même vraiment fou d'indexation comme x[4:100:5, :-10:-1, None]
est "normal" d'indexation et sera de retour vue, alors n'hésitez pas à utiliser toutes sortes de découpage astuces sur de grands tableaux.
x.astype(<dtype>)
sera de retour une copie des données que le nouveau type, tout enx.view(<dtype>)
sera de retour d'une vue.
Soyez prudent avec cela, cependant... Il est extrêmement puissant et utile, mais vous avez besoin de comprendre comment les données sous-jacentes sont stockées dans la mémoire. Si vous avez un tableau de chars, et de les considérer comme des entiers, (ou vice versa) numpy va interpréter le sous-jacent de bits de la matrice comme ints.
Par exemple, cela signifie qu' 1.0
comme un 64 bits float sur un little-endian système sera 4607182418800017408
lorsqu'on la considère comme un 64 bits de type int, et un tableau d' [ 0, 0, 0, 0, 0, 0, 240, 63]
si elle est considérée comme un uint8. C'est vraiment agréable quand vous avez besoin de faire des bits de tripoter de la sorte sur de grands tableaux, mais... Vous avez un faible niveau de contrôle sur la façon dont la mémoire tampon est interprété.