Copie en profondeur d'une np.tableau de np.tableau

J'ai un tableau numpy des différents tableaux numpy et je veux faire une copie de tableaux. J'ai trouvé de la manière suivante:

import numpy as np

pairs = [(2, 3), (3, 4), (4, 5)]
array_of_arrays = np.array([np.arange(a*b).reshape(a,b) for (a, b) in pairs])

a = array_of_arrays[:] # Does not work
b = array_of_arrays[:][:] # Does not work
c = np.array(array_of_arrays, copy=True) # Does not work
d = np.array([np.array(x, copy=True) for x in array_of_arrays])

array_of_arrays[0][0,0] = 100
print a[0][0,0], b[0][0,0], c[0][0,0], d[0][0,0]

Est d la meilleure façon de le faire? Est-il une copie en profondeur de la fonction que j'ai manqué?
Et quelle est la meilleure façon d'interagir avec chaque élément de ce tableau de différentes tailles de tableaux?

Vous devriez vraiment développer sur le "ne fonctionne pas" lignes.

OriginalL'auteur Dominik Müller | 2016-06-02

  1. 12
    import numpy as np
import copy

pairs = [(2, 3), (3, 4), (4, 5)]
array_of_arrays = np.array([np.arange(a*b).reshape(a,b) for (a, b) in pairs])

a = copy.deepcopy(array_of_arrays)

    N'hésitez pas à lire plus à propos de ce ici.

    Oh, ici est la plus simple des cas de test:

    a[0][0,0]
print a[0][0,0], array_of_arrays[0][0,0]

    OriginalL'auteur Tomasz Plaskota

  2. 4

    Battu par minute. En effet, propriétédeepcopy est la réponse ici.

    À votre deuxième question buter indexation: j'ai le sentiment que vous pourriez être mieux avec une simple liste ou un dictionnaire de type de structure de données ici. np.les matrices de sens surtout si chaque élément du tableau est du même type. Bien sûr, vous pouvez dire que chaque élément dans array_of_arrays est un autre tableau, mais quel est l'avantage de les avoir recueillies dans un tableau numpy au lieu d'une simple liste?

    list_of_arrays = [np.arange(a*b).reshape(a,b) for (a, b) in pairs]

    OriginalL'auteur maschu

  3. 2
    In [276]: array_of_arrays
Out[276]: 
array([array([[0, 1, 2],
       [3, 4, 5]]),
       array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]]),
       array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])], dtype=object)

    array_of_arrays est dtype=object; ce qui signifie que chaque élément du tableau est un pointeur vers un objet autre endroit dans la mémoire. Dans ce cas, ces éléments sont des tableaux de différentes tailles. 

    a = array_of_arrays[:]

    a est un nouveau tableau, mais une vue de array_of_arrays; c'est, il a le même tampon de données (qui dans ce cas est la liste de pointeurs).

    b = array_of_arrays[:][:]

    c'est juste une vue de la une vue. La deuxième [:] agit sur le résultat de la première.

    c = np.array(array_of_arrays, copy=True)

    C'est le même que array_of_arrays.copy(). c a un nouveau tampon de données, une copie de l'original, de

    Si je remplace un élément de c, cela n'affectera pas array_of_arrays:

    c[0] = np.arange(3)

    Mais si je modifie un élément de c, il va modifier l'élément même dans array_of_arrays - parce qu'ils pointent vers le même tableau.

    Le même genre de chose s'applique à la imbriquée listes de listes. Ce array ajoute est le view cas.

    d = np.array([np.array(x, copy=True) for x in array_of_arrays])

    Dans ce cas, vous faites des copies des éléments individuels. Comme d'autres l'ont noté, il est un deepcopy fonction. Il a été conçu pour des choses comme des listes de listes, mais fonctionne sur les tableaux. C'est fondamentalement ce que vous faites avec d, récursivement de travail en bas de la nidification de l'arbre.

    En général, un objet array est comme la liste de nidification. Quelques opérations de la croix-l'objet de limites, par exemple

     array_of_arrays+1

    mais même cela est effectivement

    np.array([x+1 for x in array_of_arrays])

    Une chose qu'un tableau d'objets ajoute, par rapport à une liste d'opérations comme reshape. array_of_arrays.reshape(3,1) rend 2d; si elle avait 4 éléments que vous pourriez faire array_of_arrays.reshape(2,2). Quelques fois c'est très pratique; d'autres fois, c'est une douleur (il est plus difficile d'itérer).

    OriginalL'auteur hpaulj