web-dev-qa-db-fra.com

Comment ajouter des éléments à un tableau à 3 dimensions en python

J'essaie de stocker des données dans un tableau à trois dimensions, c'est-à-dire x[0][0][0] en Python. Comment initialiser x et y ajouter des valeurs? J'ai essayé ceci:

x=[]
x[0][0][0]=value1 
x[0][0].append(value1)

les deux lignes donnent une erreur hors de portée. Comment faire? Je le veux comme: x[0][0][0]=value1, x[1][0][0]=value2, x[0][1][0]=value3 etc. Comment y parvenir en Python? 

Je cherche à générer ce genre de tableau:

x=[[[11,[111],[112]],[12],[13]],[[21,[211],[212]],[22],[23],[24]],[[31],[32]]]
x[0][0][0] will give 11
x[1][0][0]  21
x[0][0][1] 111

etc.

pythonarraysmultidimensional-array
8
lokesh

Je recommande d'utiliser numpy pour les tableaux multidimensionnels. Cela le rend beaucoup plus pratique et beaucoup plus rapide. Cela ressemblerait à:

import numpy as np
x = np.zeros((10,20,30)) # Make a 10 by 20 by 30 array
x[0,0,0] = value1

Néanmoins, si vous ne souhaitez pas utiliser numpy, ou si vous avez besoin de tableaux multidimensionnels non rectangulaires, vous devrez le traiter comme une liste de listes de listes et initialiser chaque liste:

x = []
x.append([])
x[0].append([])
x[0][0].append(value1)

Edit: Vous pouvez aussi utiliser la notation compacte indiquée dans la réponse de ndpu (x = [[[value1]]]).

22
amaurea

Si vous créez un tableau 3D éparse, vous pouvez enregistrer toutes les données dans un dict:

x={}
x[0,0,0] = 11
x[1,0,0] = 21
x[0,1,1] = 111

ou:

from collections import defaultdict
x = defaultdict(lambda :defaultdict(lambda :defaultdict(int)))

x[0][0][0] = 11
x[1][0][0] = 21
x[0][0][1] = 111
6
HYRY

Si vous pouvez utiliser numpy, vous pouvez initialiser un tableau de taille fixe en tant que:

import numpy
x = numpy.zeros((i, j, k))

où i, j et k sont les dimensions requises.

Vous pouvez ensuite indexer dans ce tableau en utilisant la notation slice:

x[0, 0, 0] = value1
x[1, 0, 0] = value2
3
Andrew Walker
>>> x=[[[[]]]]
>>> x[0][0][0]=0
>>> x
[[[0]]]
>>> x[0][0].append(1)
>>> x
[[[0, 1]]]
2
ndpu

Je viens juste de proposer ça, c'est plus simple et dynamique.

# Define how large to make the object.
size = 3

# Build the three dimensional list.
memory = []
for x in range(0,size):
    memory.append([])
    for y in range(0,size):
        memory[x].append([])
        for z in range(0,size):
           memory[x][y].append(0) # Fill with zeros.

# Iterate through all values.
for x in range(0,size):
    for y in range(0,size):
        for z in range(0,size):
            print 'memory[' + str(x) + '][' + str(y) + '][' + str(z) + ']=' + str(memory[x][y][z])

# Example access.
print 'Example access:'
print 'memory[0][1][2]=' + str(memory[0][1][2])

Sortie:

memory[0][0][0]=0
memory[0][0][1]=0
memory[0][0][2]=0
memory[0][1][0]=0
memory[0][1][1]=0
memory[0][1][2]=0
memory[0][2][0]=0
memory[0][2][1]=0
memory[0][2][2]=0
memory[1][0][0]=0
memory[1][0][1]=0
memory[1][0][2]=0
memory[1][1][0]=0
memory[1][1][1]=0
memory[1][1][2]=0
memory[1][2][0]=0
memory[1][2][1]=0
memory[1][2][2]=0
memory[2][0][0]=0
memory[2][0][1]=0
memory[2][0][2]=0
memory[2][1][0]=0
memory[2][1][1]=0
memory[2][1][2]=0
memory[2][2][0]=0
memory[2][2][1]=0
memory[2][2][2]=0
Example access:
memory[0][1][2]=0
1
Wayne Workman

Une compilation des techniques ci-dessus permettant de créer efficacement un dict à deux dimensions est:

from collections import defaultdict
x = defaultdict(lambda :defaultdict())
x["a"]["b"] = 123
x["a"]["c"] = 234
x["b"]["a"] = 234    
x["b"]["c"] = 234    
x["c"]["a"] = 234
x["c"]["b"] = 234
for i in x: 
    for j in x[i]: print i, j, x[i][j]

Produit:

a c 234
a b 123
c a 234
c b 234
b a 234
b c 234

Pour augmenter le nombre de dimensions (par exemple, à trois dimensions), augmentez simplement le "nid" lambda comme le montre HYRY:

x = defaultdict(lambda :defaultdict(lambda :defaultdict(int)))
0
user2099484

Interator. J'utilise la fonction lambda pour créer une matrice avec [[0 pour j dans la plage (n)] pour i dans la plage (m)] en python 3. Dans la version 2, une carte utilise les fonctions. En ce moment, pensez à utiliser le module de tableau (pur Python) pour créer des matrices.

>>> arr = lambda m,n,l : [ [ [0 for k in range(l)] for j in range(n)] for i in range(m) ]
>>> m = arr(2,3,4)
>>> m
    [[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
0
Peter Hausdorff Smith K.