Rellene la lista bidimensional con valores en lugar de inicializarla primero con ceros

Tengo una matriz bidimensional que quiero llenar con valores que representan poderes, pero mi problema radica en la velocidad del código porque la matriz bidimensional tiene un tamaño de 100×100 y no quiero inicializarlo primero con la lista de 100×100. Los zereos luego llenan la lista con valores, pero llenan la lista bidimensional de 100×100 por valores directamente. Mi código se muestra abajo

x_list = np.linspace(min_x, max_x, (max_x - min_x)+1) y_list = np.linspace(min_y, max_y, (max_y - min_y)+1) X, Y = np.meshgrid(x_list, y_list) Y = Y[::-1] Z = [[0 for x in range(len(x_list))] for x in range(len(y_list))] #Z is the two-dimensional list containing powers of reach position in the structure to be plotted for each_axes in range(len(Z)): for each_point in range(len(Z[each_axes])): Z[len(Z)-1-each_axes][each_point] = power_at_each_point(each_point, each_axes) #The method power_at_each_point is the one that calculates the values in the two-dimensional array Z 

Un ejemplo de lo que quiero hacer es, en lugar de hacer lo que se muestra a continuación:

 Z_old = [[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] for each_axes in range(len(Z_old)): for each_point in range(len(Z_old[each_axes])): Z_old[len(Z_old)-1-each_axes][each_point] = power_at_each_point(each_point, each_axes) 

Ahora quiero no inicializar la matriz Z_old con ceros, sino más bien llenarla con valores mientras itero a través de ella, que será algo como lo que se escribe a continuación, aunque su syntax es terriblemente errónea, pero eso es lo que quiero alcanzar al final.

  Z = np.zeros((len(x_list), len(y_list))) for Z[len(x_list) -1 - counter_1][counter_2] is equal to power_at_each_point(counter_1, counter_2] for counter_1 in range(len(x_list)) and counter_2 in range(len(y_list))] 

más el método de power_at_each_point se muestra a continuación con sus métodos relacionados si te ayuda a entender lo que quería hacer:

  #A method to calculate the power reached from one node to the other for contourf function def cal_pow_rec_plandwall_contour(node_index_tx, receiver): nodess_excel = xlrd.open_workbook(Node_file_location) nodes_sheet = nodess_excel.sheet_by_index(0) node_index_tx_coor = [nodes_sheet.cell_value(node_index_tx - 1, 3), nodes_sheet.cell_value(node_index_tx - 1, 4)] #just co-ordinates of a point distance = cal_distance(node_index_tx_coor, receiver) if distance == 0: power_rec = 10 * (np.log10((nodes_sheet.cell_value(node_index_tx - 1, 0) * 1e-3))) return power_rec #this is the power received at each position else: power_rec = 10 * (np.log10((nodes_sheet.cell_value(node_index_tx - 1, 0) * 1e-3))) - 20 * np.log10((4 * math.pi * distance * 2.4e9) / 3e8) - cal_wall_att([node_index_tx_coor, receiver]) return power_rec def power_at_each_point(x_cord, y_coord): #A method to get each position in the structure and calculate the power reached at that position to draw the structure's contourf plot fa = lambda xa: cal_pow_rec_plandwall_contour(xa, [x_cord, y_coord]) return max(fa(each_node) for each_node in range(1, len(Node_Positions_Ascending) + 1)) #Node_position_ascending is a list containing the co-ordinate positions of markers basically or nodes. 

Si alguien pudiera decirme cómo puedo llenar la matriz bidimensional Z con valores desde la parte inferior de la parte superior como lo hice allí sin haber establecido inicialmente la matriz bidimensional en cero, sería muy apreciado.

OK, primero, desea crear una matriz NumPy, no una lista de listas. Esto casi siempre será significativamente más pequeño y un poco más rápido para trabajar. Y, lo que es más importante, abre la puerta a la vectorización de sus bucles, lo que los hace mucho más rápidos para trabajar. Entonces, en lugar de esto:

 Z_old = [[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] 

… hacer esto:

 Z_old = np.zeros((3, 5)) 

Pero ahora veamos si podemos vectorizar su bucle en lugar de modificar los valores:

 for each_axes in range(len(Z_old)): for each_point in range(len(Z_old[each_axes])): Z_old[len(Z_old)-1-each_axes][each_point] = each_point**2 + each_axes**2 

Los valores iniciales de Z[…] no se utilizan en absoluto aquí, por lo que no necesitamos rellenarlos previamente con 0, tal como sospechaba. Lo que se usa en cada punto es r y c . (Voy a cambiar el nombre de Z_old , each_axes , y each_point a Z , r , c por brevedad.) En particular, está tratando de establecer cada Z[len(Z)-1-r, c] a r**2 + c**2 .

Primero, invirtamos los negativos para que esté configurando cada Z[r, c] a algo, en este caso, a (len(Z)-1-r)**2 + c**2 .

Ese “algo” es solo una función en los valores r y c . Que podemos obtener creando arange s. En particular, arange(5) es solo una matriz de los números 0, 1, 2, 3, 4 y arange(5)**2 es una matriz de los cuadrados 0, 1, 4, 9, 16 .

El único problema es que para obtener una matriz de 3×5 de esto, tenemos que agregar elementalmente dos matrices 2D, una matriz de 3×1 y una matriz de 1×5, viceversa, pero tenemos dos matrices de 1D de arange . Bueno, podemos reshape uno de ellos:

 Z_old = (3 - 1 - np.arange(3))**2 + (np.arange(5)**2).reshape((5, 1)) 

Por supuesto, puede simplificar esto aún más (obviamente no necesita 3 - 1 , y simplemente puede agregar un nuevo eje sin reshape ), pero es de esperar que esto muestre directamente cómo se corresponde con su código original.