Cómo agregar elementos a la matriz tridimensional en Python

Estoy tratando de almacenar datos en una matriz tridimensional, es decir, x[0][0][0] en Python. ¿Cómo inicializar x , y agregarle valores? He intentado esto:

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

Ambas líneas están dando error fuera de rango. ¿Cómo hacerlo? Lo quiero como: x[0][0][0]=value1 , x[1][0][0]=value2 , x[0][1][0]=value3 etc. Cómo lograr esto en ¿Pitón?

Estoy buscando generar este tipo de matriz:

 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.

Recomiendo usar numpy para arreglos multidimensionales. Lo hace mucho más conveniente, y mucho más rápido. Esto se vería como:

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

Aún así, si no desea usar numpy , o necesita matrices multidimensionales no rectangulares, deberá tratarlo como una lista de listas de listas e inicializar cada lista:

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

Edición: O podría usar la notación compacta que se muestra en la respuesta de ndpu ( x = [[[value1]]] ).

Si está creando una matriz dispersa 3D, puede guardar todos los datos en un dict:

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

o:

 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 

Si puede usar numpy, puede inicializar una matriz de tamaño fijo como:

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

donde i, j y k son las dimensiones requeridas.

Luego puedes indexar en esa matriz usando notación de segmento:

 x[0, 0, 0] = value1 x[1, 0, 0] = value2 
 >>> x=[[[[]]]] >>> x[0][0][0]=0 >>> x [[[0]]] >>> x[0][0].append(1) >>> x [[[0, 1]]] 

Acabo de llegar a esto, es más dynamic y simple.

 # 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]) 

Salida:

 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 

Una comstackción de las técnicas anteriores con respecto a la creación efectiva de un dictado bidimensional es:

 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] 

Produce:

 ac 234 ab 123 ca 234 cb 234 ba 234 bc 234 

Para boost el número de dimensiones (por ejemplo, a tres dimensiones), simplemente aumente el “nido” lambda como muestra HYRY:

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

Interator Uso la función lambda para crear matriz con [[0 para j en el rango (n)] para i en el rango (m)] en Python 3. En la versión 2, se usan funciones de mapa. En este momento, piense como usar el módulo de matriz (python puro) para crear 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]]]