将浮点数传递到嵌套的 for 循环并存储输出

Question

我在Matlab方面有很强的背景，我正在尝试切换到python。我正在尝试编写一个带有 numpy 数组的嵌套 for 循环并存储输出值。

我的代码读起来像这样：

import numpy as np
import math
# T parameter
kk = np.arange(0, 20, 0.1)
print(len(kk))
# V parameter
pp = np.arange(1, 5, 1)
print(len(pp))
a = len(kk)
b = len(pp)
P = np.zeros((a,b))

for T in kk:
print(T)
for V in pp:
print(V)
P = math.exp(-T*V/10)
print(P)

解释/问题

1. kk，pp是向量。在 for 循环中，正在调用 T 和 V 参数的正确值。但是，不会存储P的值。

2. 我尝试了以下更改P[T][V] = math.exp(-T*V/10)，出现以下错误：索引错误：只有整数，切片(:(，省略号(...(，numpy.newaxis(None(和整数或布尔数组是有效的索引

任何帮助将不胜感激。提前谢谢你。

Answer 1

在此代码中，您将P定义为二维数组。 但是，将math.exp表达式的标量结果分配给该变量的循环。 这将替换原始P值，也会替换在上一个循环中计算的值。 这种循环在 MATLAB 中不起作用是吗？ 您不必将标量值分配给P中的某个"插槽"吗？

P = np.zeros((a,b))
for T in kk:
print(T)
for V in pp:
print(V)
P = math.exp(-T*V/10)

更好的方法：

In [301]: kk = np.arange(0,20,0.1)                                                            
In [302]: kk.shape                                                                            
Out[302]: (200,)
In [303]: pp = np.arange(1, 5,1)                                                              
In [304]: pp.shape                                                                            
Out[304]: (4,)

在numpy我们更喜欢使用快速的全数组方法。 在这里，我使用broadcasting来执行类似计算outerkk与pp。

In [305]: P = np.exp(-kk[:,None]*pp/10)                                                       
In [306]: P.shape                                                                             
Out[306]: (200, 4)

(我相信 MATLAB 近年来增加了broadcasting;numpy从一开始就拥有它。

将其与迭代版本进行比较：

In [309]: P1 = np.zeros((200,4)) 
...: for i in range(0,len(kk)): 
...:     for j in range(0,len(pp)): 
...:         T = kk[i] 
...:         V = pp[j] 
...:         P1[i,j] = math.exp(-T*V/10) 
...:                                                                                     
In [310]: P1.shape                                                                            
Out[310]: (200, 4)
In [311]: np.allclose(P,P1)                                                                   
Out[311]: True

在 Python 中编写索引迭代的一种更简洁的方法是使用enumerate：

In [312]: P1 = np.zeros((200,4)) 
...: for i,T in enumerate(kk): 
...:     for j,V in enumerate(pp): 
...:         P1[i,j] = math.exp(-T*V/10) 

Answer 2

根据您提到的尝试P[T][V] = math.exp(-T*V/10)的行，您可能也对此选项感兴趣：

import numpy as np
import math
# T parameter
kk = np.arange(0, 20, 0.1)
print(len(kk))
# V parameter
pp = np.arange(1, 5, 1)
print(len(pp))
a = len(kk)
b = len(pp)
P = np.zeros((a,b))
for i in range(0,len(kk)):
for j in range(0,len(pp)):
T = kk[i]
V = pp[j]
P[i][j] = math.exp(-T*V/10)
# you can also simply do this:
#P[i][j] = math.exp(-kk[i]*pp[j]/10)

虽然很简单，但并不是特别干净。既然你提到你要切换到python，我会看看hpaulj的答案，以获得更彻底的解释，以及迭代数组的一个很好的选择。

Answer 3

如果您想查看keys并根据您的评论values，您可以制作字典。这实际上可能更有意义。我建议不要使用过多的动态创建的变量，就像字典一样，您可以调用整个字典或特定值，以后可以将其存储为变量。显然，这取决于您的项目范围以及哪种解决方案有意义，但您也可以将字典变成具有pd.DataFrame()进行分析的pandasdataframe，因此它为您提供了灵活性。你说你是python的新手，所以如果你没有听说过它，你可能想看看熊猫，但你可能有，因为它是最受欢迎的库之一。

import numpy as np
import math
P_dict = {}
# T parameter
kk = np.arange(0, 20, 0.1)
# print(len(kk))
# V parameter
pp = np.arange(1, 5, 1)
# print(len(pp))
a = len(kk)
b = len(pp)
P = np.zeros((a,b))

for T in kk:
#     print(T)
for V in pp:
#         print(V)
P = math.exp(-T*V/10)
key = f'{T},{V}'
value = P
P_dict[key] = value
print(P_dict)

这就是您根据键在字典中调用值的方式。

P_dict['19.900000000000002,3']

您还可以将这行代码编辑为所需的任何格式：key = f'{T},{V}'并根据格式调用密钥，就像我在示例中所做的那样。

输出：0.002554241418992996

无论哪种方式，列表或字典都会打印一些有趣的python抽象艺术！