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

我有很强的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）

，我得到了以下错误：索引器：只有整数、片（

：

）、省略号（

…

）、numpy.newaxis（

None

）和整数或布尔数组是有效的索引

---

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

如果您想查看注释中的

键和
值，可以制作一本词典。实际上，这可能更有意义。我建议不要使用过多的动态创建的变量，就像使用字典一样，您可以调用整个字典或特定的值，稍后您可以将其存储为变量。显然，这取决于您的项目范围和什么解决方案是有意义的，但是您也可以将字典转换为一个
dataframe
，使用
pd.dataframe（）
进行分析，因此它为您提供了灵活性。你说你是python新手，所以如果你没有听说过它，你可能想看看pandas，但是你可能听说过，因为它是最流行的库之一

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)

这就是基于键调用dict中的值的方式

P_dict['19.900000000000002,3']

您还可以将这行代码编辑为您想要的任何格式：
key=f'{T}，{V}'
，并按照我在示例中所做的格式调用键

输出：
0.0025542418992996

无论哪种方式，列表或dict都会打印出一些有趣的python抽象艺术
 如果您想查看每个注释的
键和
值，可以制作一个字典。实际上，这可能更有意义。我建议不要使用过多的动态创建的变量，就像使用字典一样，您可以调用整个字典或特定的值，稍后您可以将其存储为变量。显然，这取决于您的项目范围和什么解决方案是有意义的，但是您也可以将字典转换为一个
dataframe
，使用
pd.dataframe（）
进行分析，因此它为您提供了灵活性。你说你是python新手，所以如果你没有听说过它，你可能想看看pandas，但是你可能听说过，因为它是最流行的库之一

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)

这就是基于键调用dict中的值的方式

P_dict['19.900000000000002,3']

您还可以将这行代码编辑为您想要的任何格式：
key=f'{T}，{V}'
，并按照我在示例中所做的格式调用键

输出：
0.0025542418992996

无论哪种方式，列表或dict都会打印出一些有趣的python抽象艺术
 根据您提到的trying
p[T][V]=math.exp（-T*V/10）
这一行，您可能还对该选项感兴趣：

将numpy导入为np
输入数学
#T参数
kk=np.arange（0,20,0.1）
印刷品（len（kk））
#V参数
pp=np.arange（1,5,1）
印刷品（透镜（pp））
a=len（kk）
b=len（pp）
P=np.零（（a，b））
对于范围（0，len（kk））内的i：
对于范围（0，len（pp））内的j：
T=kk[i]
V=pp[j]
P[i][j]=数学经验（-T*V/10）
#您也可以简单地执行以下操作：
#P[i][j]=math.exp（-kk[i]*pp[j]/10）

虽然很简单，但并不特别干净。既然您提到要切换到python，我想看看hpaulj的答案，以获得更全面的解释，以及迭代数组的一个很好的替代方案。
基于您提到的trying
p[T][V]=math.exp（-T*V/10）
，您可能还对这个选项感兴趣：

将numpy导入为np
输入数学
#T参数
kk=np.arange（0,20,0.1）
印刷品（len（kk））
#V参数
pp=np.arange（1,5,1）
印刷品（透镜（pp））
a=len（kk）
b=len（pp）
P=np.零（（a，b））
对于范围（0，len（kk））内的i：
对于范围（0，len（pp））内的j：
T=kk[i]
V=pp[j]
P[i][j]=数学经验（-T*V/10）
#您也可以简单地执行以下操作：
#P[i][j]=math.exp（-kk[i]*pp[j]/10）

虽然很简单，但并不特别干净。既然您提到要切换到python，我想看看hpaulj的答案，以获得更透彻的解释，以及迭代数组的一个很好的替代方法。
在这段代码中，您将
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) 

在此代码中，您将
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
中，我们更喜欢