Construire un tableau numpy/scipy par itération en Python?
Souvent, je fais construire un tableau à partir de certaines données, par exemple:
my_array = []
for n in range(1000):
# do operation, get value
my_array.append(value)
# cast to array
my_array = array(my_array)
Je trouve que j'ai d'abord construire une liste et ensuite de voter pour elle (à l'aide de "tableau") à un tableau. Est-il un moyen de contourner ces? Tous ces appels de casting de l'encombrement du code... comment puis-je construire itérativement jusqu' "my_array", avec un tableau depuis le début?
- qu'advient-il si vous ne le faites pas?
- La raison numpy est si rapide, en premier lieu, c'est qu'il fonctionne avec la constante de la taille des tableaux et non des listes dynamiques. Afin de se débarrasser de lui juste pour réduire le "fouillis" dans votre code n'est probablement pas la bonne façon de faire. Si vous connaissez la taille à l'avance (1000) préallouer il. Si vous n'avez pas de construction de la liste est certainement la meilleure façon d'aller, comme python, les listes [] sont assez efficaces.
Vous devez vous connecter pour publier un commentaire.
Si je comprends votre question correctement, cela devrait faire ce que vous voulez:
NumPy fournit un " fromiter méthode:
qui donne
np.fromiter
et vous connaissez la taille de la matrice à l'avance, vous pouvez le passer en paramètre le tableau devient pré-alloués. Cela augmente considérablement les performances. Ainsi dans l'exemple ci-dessus, n':np.fromiter(myfunc(5), dtype=int, count=5)
Recommandé de le faire est de préallouer avant la boucle et l'utilisation de tranchage et d'indexation pour insérer
numpy ne fournir un
array.resize()
méthode, mais ce sera beaucoup plus lent en raison du coût de la réallocation de mémoire à l'intérieur d'une boucle. Si vous doit avoir de la flexibilité, alors je crains que le seul moyen est de créer unarray
à partir d'unlist
.EDIT: Si vous êtes inquiet que vous êtes d'allouer trop de mémoire pour vos données, je voudrais utiliser la méthode ci-dessus à la sur-allouer et puis, quand la boucle est terminée, lop off le solde non utilisé des morceaux de la matrice à l'aide de
array.resize()
. Ce sera loin, loin plus rapide que de constamment la répartition de la matrice à l'intérieur de la boucle.EDIT: En réponse à @user248237 commentaire, en supposant que vous savez de toute une dimension de la matrice (pour des raisons de simplicité):
Le principe général est "d'allouer plus que vous pensez que vous aurez besoin, et si les choses changent, redimensionner le tableau que peu de fois que possible". Le doublement de la taille peut être considéré comme excessif, mais en fait, c'est la méthode utilisée par plusieurs structures de données dans plusieurs bibliothèques standard dans d'autres langues (
java.util.Vector
le fait par défaut par exemple. Je pense que plusieurs implémentations destd::vector
en C++ ce faire ainsi).resize()
quand la boucle est terminée. Si vous réduisez la taille du tableau à la bonne taille, vous permettra de jeter tous les zéro éléments.