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)

说明/问题

kk ， pp 。在for循环中，将调用T和V参数的正确值。但是，不会存储 P 的值。
我尝试了以下更改P[T][V] = math.exp(-T*V/10)，收到以下错误： IndexError：仅整数，切片（:），省略号（...），numpy .newaxis（None）和整数或布尔数组是有效索引

任何帮助将不胜感激。预先谢谢你。

Answer 1

根据您提到尝试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 2

在此代码中，您将P定义为2d数组。但是，循环将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来执行outer，类似于使用kk计算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 3

如果您想在评论中看到keys和values，则可以制作字典。实际上，这可能更有意义。我建议不要使用过多的动态创建的变量，就像使用字典一样，您可以调用整个字典或特定值，无论如何以后都可以将它们存储为变量。显然，这取决于项目的范围以及哪种解决方案有意义，但是您也可以将字典转换为带有pandas的{{1}} dataframe进行分析，从而为您提供了灵活性。您说您是python的新手，所以如果您还没有听说过pandas的话，可能想看看它，但是您可能已经拥有它，因为它是python之一或最受欢迎的库。

pd.DataFrame()

这是基于键在字典中调用值的方式。

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}'

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

将float传递给嵌套的for循环并存储输出

3 个答案: