Python 用值填充二维列表，而不是先用零初始化它

我有一个二维数组，我想用表示幂的值填充它，但我的问题在于代码的速度，因为二维数组的大小是100x100，我不想先用100x100个zereos列表初始化它，然后用值填充列表，而是用值填充100x100个二维列表直接的。我的代码如下所示

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

我想做的一个例子是，不要做下面所示的事情：

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)

我现在不想用零初始化Z_old数组，而是在遍历它时用值填充它，这将类似于下面所写的内容，虽然它的语法非常错误，但这就是我希望最终达到的目的

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

另外，如果有助于您理解我想做的事情，下面将显示每个点的增强方法及其相关方法：

 #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.

---

如果有人能告诉我，如果我不首先将二维数组设置为零，如何用顶部底部的值填充二维数组Z，我将不胜感激。

好的，首先，您要创建一个NumPy数组，而不是列表列表。这几乎总是要小得多，而且工作起来要快一点。而且，更重要的是，它打开了对循环进行矢量化的大门，这使它们的处理速度大大加快。因此，与此相反：

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

…这样做：

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

但现在让我们看看是否可以将循环矢量化，而不是修改值：

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

这里根本不使用

Z[…]

的初始值，因此我们不需要像您所怀疑的那样，预先用0填充它们。在每个点上使用的是

r

和

c

。（为了简洁起见，我将把你的

Z_-old

，

each_-axes

，和

each_-point

重命名为

Z

，

r

，和

c

）特别是，你试图将每个

Z[len（Z）-1-r，c]

设置为

r**2+c**

首先，让我们反转负片，这样您就可以将每个
Z[r，c]
设置为某个值，在本例中，设置为
（len（Z）-1-r）**2+c**2

“某物”只是
r
和
c
值的函数。我们可以通过创建
arange
s来获得。特别是，
arange（5）
只是一个数字数组
0，1，2，3，4
，而
arange（5）**2
是一个正方形数组
0，1，4，9，16

唯一的问题是，要从中获得3x5阵列，我们必须在元素上添加两个2D阵列，一个3x1阵列和一个1x5阵列，反之亦然，但我们从
arange
中获得了两个1D阵列。好吧，我们可以重塑其中一个：

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

当然，您可以进一步简化它（您显然不需要
3-1
，您可以添加一个新的轴，而不必
重塑
），但希望这可以直接显示它与原始代码的对应关系。
为什么要使用Z的列表，而不只是使用NumPy 2D数组？预填充数组然后替换值可能会使代码花费1.5倍的时间，但在Python中使用列表和循环会使代码花费10倍的时间，这当然是一个更大的问题？同时，您能否给我们一个与实际代码类似的、不太有效的代码，而不是一些不完整的代码，而且里面有不相关的东西吗？你能把函数
power…
？也许可以把它矢量化？如果不是，我会尝试使用列表而不是数组。如果速度是个大问题，你可以使用cython或f2py。@abarnert是的，我认为这是问题之一，但我对python不太熟悉，所以我尽量简化了它。你能帮我写一篇文章，告诉我如何修改代码，以便它能更快地实现我上面所做的事情吗？@MahmoudAyman：这正是莫里茨和我都要求的原因一个完整的例子。如果我们能准确地看到你在做什么，我们可以向你展示如何用numpy数组做同样的事情，希望还有numpy向量运算，你可以理解它是如何与你展示的内容相对应的。如果我们看到一些不同的东西，你能得到的最好的是一个模糊的例子，它可能与你的真实代码无关，并且可能很难理解。你把你说的否定句颠倒过来的部分，我试图将每个
Z[r，c]
设置为
（len（Z）-1-r）**2+c**2
，但在我的情况下，我正在设置位置
Z[len Z）-1-r，c]
在2D数组中改为
r**2+c**2
。@MahmoudAyman:但这是完全一样的。看看这个简化：将
Z[3-1-0]
设置为
f（0）
，
Z[3-1-1]
设置为
f（1）
，
Z[3-1-2]
设置为
f（0）
设置为
f（3-1-0）
，
Z[1]/code>设置为
f（3-1-1）
，设置为
f（2）
。在每种情况下，
Z[0]==f（2）
，
Z[1]==f（1）
，以及
Z[2]==f（0）
。（如果你真的不相信这一点，你总是可以倒过来构建数组，然后通过索引
[：：-1]
翻转它；这只会浪费一点点时间…）哦，是的，我现在看到了。那么对于我的原始代码，
（3-1-np.arange（3））**2
在哪里合适呢？因为在我的代码中，我并不是真正地平方每个位置，而是在每个点上执行power方法。我想替换你的示例行
Z_old=（3-1-np.arange（3））**2+（np.arange（5）**2）。重塑（（5，1））
以适应我的
Z[len（Z）-1-每个_轴][每个_点]=每个_点的功率（每个_点，每个_轴）
。现在什么与len（Z）相对应？我如何才能在内部调用我的方法，而不是将平方作为一个函数？@MahmoudAyman：你必须弄清楚如何将操作矢量化。您能否根据数组中已经存在（或很容易获得）的值在每个点实现
power\u？在这种情况下，真正的勇气