Python 对于这个特殊任务，字典或元组列表会更有效吗？

我写了一个脚本，目的是通过试错法（马尔可夫链蒙特卡罗法）找到最适合函数的参数。参数的可行性由chi值判断——chi越低越好

下面是我目前编写的代码的一部分：

chi1 = fun_chi(B1,G1,C11,C21,C31,C41,C01)
BGCchilist = []
count = -1

for i in range(iteration_MCMC):
    count = count + 1
    print(count)
    B2,G2,C12,C22,C32,C42,C02 = gen_param(B1,G1,C11,C21,C31,C41,C01)
    chi2 = fun_chi(B2,G2,C12,C22,C32,C42,C02)
    ratio = np.exp((-chi2 + chi1) / 2)
    rand = np.random.uniform(0,1)
    if rand < ratio:
        B1 = B2
        G1 = G2
        C11 = C12
        C21 = C22
        C31 = C32
        C41 = C42
        C01 = C02
        chi1 = chi2
    ##save the data
    Bsave = B1
    Gsave = G1
    C1save = C11
    C2save = C21
    C3save = C31
    C4save = C41
    C0save = C01
    chisave = chi1
    BGCchilist.append((Bsave,Gsave,C1save,C2save,C3save,C4save,C0save,chisave))

Blist = [x[0] for x in BGCchilist]
Glist = [x[1] for x in BGCchilist]
C1list = [x[2] for x in BGCchilist]
C2list = [x[3] for x in BGCchilist]
C3list = [x[4] for x in BGCchilist]
C4list = [x[5] for x in BGCchilist]
C0list = [x[6] for x in BGCchilist]
chilist = [x[7] for x in BGCchilist]
minchi = min(x[7] for x in BGCchilist)
mintuple = [x for x in BGCchilist if x[7] == minchi]

chi1=fun\u chi（B1、G1、C11、C21、C31、C41、C01）
bgchilist=[]
计数=-1
对于范围内的i（迭代\u MCMC）：
计数=计数+1
打印（计数）
B2、G2、C12、C22、C32、C42、C02=发电机参数（B1、G1、C11、C21、C31、C41、C01）
chi2=fun_chi（B2、G2、C12、C22、C32、C42、C02）
比率=np.exp（（-chi2+chi1）/2）
rand=np.随机.均匀（0,1）
如果兰特<比率：
B1=B2
G1=G2
C11=C12
C21=C22
C31=C32
C41=C42
C01=C02
chi1=chi2
##保存数据
Bsave=B1
Gsave=G1
C1save=C11
C2save=C21
C3save=C31
C4save=C41
C0save=C01
chisave=chi1
bgchilist.append（（Bsave、Gsave、C1save、C2save、C3save、C4save、C0save、chisave））
Blist=[x[0]表示BGCchilist中的x]
Glist=[x[1]代表BGCchilist中的x]
C1list=[x[2]表示BGCchilist中的x]
C2list=[x[3]代表BGCchilist中的x]
C3list=[x[4]代表BGCchilist中的x]
C4list=[x[5]代表BGCchilist中的x]
C0list=[x[6]代表BGCchilist中的x]
chilist=[x[7]代表BGCchilist中的x]
minchi=min（在BGCchilist中x[7]代表x）
mintuple=[x代表BGCchilist中的x，如果x[7]==minchi]

我最终通过Matplotlib将所有这些列表与迭代单独绘制，然后将

mintuple

保存为文本文件

一位同事对此进行了研究，并告诉我使用字典可能会更好，在字典中，每次迭代我都会执行类似于

A_dictionary[chisave]=（B，G，…C0）

的操作，然后通过查找字典中的最小值来查找

mintuple

。然而，从字典中的值元组中提取列表以进行绘图似乎会更加笨拙，并且需要更多的步骤

字典方法会允许更少的步骤，更高的效率，还是这是一种全列表方法

---

谢谢你的帮助

A

dict

步骤更少，也更容易阅读。使用

minchi

作为键：

BGCchilist = {}

# in the loop

    BGCchilist[chisave] = [Bsave, Gsave, C1save,C2save,C3save,C4save,C0save,chisave]

# out of the loop

minchi = min(BGCchilist.keys())
mintuple = BGCchilist[minchi]

如果需要保存导致相同chi值的每个参数组合，请更改dict以保存每个键的元组列表，而不仅仅是列表：

from collections import defaultdict

BGCchilist = defaultdict(list)

...

    BGCchilist[chisave].append([...all the saves...])

...

minchi = min(BGCchilist.keys())
mintuples = BGCchilist[minchi]
# at this point mintuples has at least one tuple of params that got
# this chi score, maybe more

更新：

好的，以下是我对您需求的理解：

• 您需要保存每个参数组合和结果的chi分数
• 完成后，您需要获得最低的chi分数
• 完成后，您需要每个输入参数和chi分数的列表

为此，我将使用一个简单的类。可能行数不会减少，但可读性会更高：

# lightly tested
class BGCChiData(object):  # (object) not needed in Python3
    def __init__(self):
        self.data = defaultdict(list)
    def __getitem__(self, chi):
        return self.data[chi]
    def __setitem__(self, chi, params):
        self.data[chi].append(params)
    @property
    def min_chi(self):
        return min(self.data.keys())
    @property
    def B(self):
        return [tup[0] for val in self.data.values() for tup in val]
    @property
    def G(self):
        return [tup[1] for val in self.data.values() for tup in val]
    @property
    def C1(self):
        return [tup[2] for val in self.data.values() for tup in val]
    @property
    def C2(self):
        return [tup[3] for val in self.data.values() for tup in val]
    @property
    def C3(self):
        return [tup[4] for val in self.data.values() for tup in val]
    @property
    def C4(self):
        return [tup[5] for val in self.data.values() for tup in val]
    @property
    def C0(self):
        return [tup[6] for val in self.data.values() for tup in val]
    @property
    def chi(self):
        return [tup[7] for val in self.data.values() for tup in val]

chi1 = fun_chi(B1,G1,C11,C21,C31,C41,C01)
BGCchi = BGCChiData()

for count in range(iteration_MCMC):
    print(count)
    B2,G2,C12,C22,C32,C42,C02 = gen_param(B1,G1,C11,C21,C31,C41,C01)
    chi2 = fun_chi(B2,G2,C12,C22,C32,C42,C02)
    ratio = np.exp((-chi2 + chi1) / 2)
    rand = np.random.uniform(0,1)
    if rand < ratio:
        B1 = B2
        G1 = G2
        C11 = C12
        C21 = C22
        C31 = C32
        C41 = C42
        C01 = C02
        chi1 = chi2
    ##save the data
    BGCchi[chi1].append(B1, G1, C11, C21, C31, C41, C01)

minchi = BGCchi.min_chi
mintuple = BGCchi[minchi]
B1list = BGCchi.B
# etc. etc.

#轻度测试
类bgchidata（对象）：#（对象）在Python3中不需要
定义初始化（自）：
self.data=defaultdict（列表）
定义获取项目（自我，chi）：
返回自我数据[chi]
定义设置项（self、chi、params）：
self.data[chi].append（参数）
@财产
def min_chi（自我）：
return min（self.data.keys（））
@财产
def B（自我）：
返回[tup[0]用于self.data中的val.values（）用于val中的tup]
@财产
def G（自我）：
返回[tup[1]用于self.data中的val.values（）用于val中的tup]
@财产
def C1（自我）：
返回[tup[2]用于self.data中的val.values（）用于val中的tup]
@财产
def C2（自我）：
返回[tup[3]用于self.data中的val.values（）用于val中的tup]
@财产
def C3（自我）：
返回[tup[4]用于self.data中的val.values（）用于val中的tup]
@财产
def C4（自身）：
返回[tup[5]用于self.data中的val.values（）用于val中的tup]
@财产
def C0（自身）：
返回[tup[6]用于self.data中的val.values（）用于val中的tup]
@财产
陈德辉（自我）：
返回[tup[7]用于self.data中的val.values（）用于val中的tup]
chi1=fun_chi（B1、G1、C11、C21、C31、C41、C01）
BGCchi=bgchidata（）
对于范围内的计数（迭代\u MCMC）：
打印（计数）
B2、G2、C12、C22、C32、C42、C02=发电机参数（B1、G1、C11、C21、C31、C41、C01）
chi2=fun_chi（B2、G2、C12、C22、C32、C42、C02）
比率=np.exp（（-chi2+chi1）/2）
rand=np.随机.均匀（0,1）
如果兰特<比率：
B1=B2
G1=G2
C11=C12
C21=C22
C31=C32
C41=C42
C01=C02
chi1=chi2
##保存数据
BGCchi[chi1]。追加（B1、G1、C11、C21、C31、C41、C01）
minchi=BGCchi.min_chi
mintuple=BGCchi[明治]
B1list=BGCchi.B
#等等等等。

这是对评论的回答。我原以为问题是关于效率的，但仔细检查后，似乎是关于如何清理代码。如果这是协商，那么以下内容可能会有用：

对于第一部分，我们只是将所有内容保持为一个元组，并像这样使用嵌入扩展

par1 = B1,G1,C11,C21,C31,C41,C01
chi1 = fun_chi(*par1)
BGCchilist = []

for i in range(iteration_MCMC):

    print (i-1)

    par2  = gen_param(*par1)
    chi2  = fun_chi(*par2)
    ratio = np.exp((-chi2 + chi1) / 2)
    rand  = np.random.uniform(0,1)
    if rand < ratio: par1 = par2
    BGCchilist.append(list(par1) + [chi1]) ##save the data

我对算法没有把握，因此无法对这一部分做出明确的评论

下一部分更有趣

Blist    = [x[0] for x in BGCchilist]
Glist    = [x[1] for x in BGCchilist]
C1list   = [x[2] for x in BGCchilist]
C2list   = [x[3] for x in BGCchilist]
C3list   = [x[4] for x in BGCchilist]
C0list   = [x[6] for x in BGCchilist]
C4list   = [x[5] for x in BGCchilist]
chilist  = [x[7] for x in BGCchilist]

可以简单地替换为：

BList,  GList,           \
C1List, C2List, C3List   \
C0List, C4List, chilist  = zip(*BGCchilist)

我想这就是它的作用。请单独检查这部分

最后，你真的需要所有的列表吗？还是只需要

辣椒酱

我想剩下的应该很简单吧？你所拥有的一切都很好。检查

min

功能中的

键

参数。因此，如果出于某种原因您不需要所有列表，您可以跳过该部分并在for循环中找到最小值，或者您可以执行以下操作：

minChi     = min( zip(*BGCchilist)[-1] )
allMinChis = filter( lambda m: m[7] == minChi, BGCchilist)

奶酪

---

注意：我没有测试代码，所以可能有错误。请仔细检查代码，确保这是您想要的

考虑到所有人都是用普通Python完成这项工作的，而不是通过numpy或scipy，我认为在最后一步中效率并不重要。如果你在寻找最合适的参数

minChi     = min( zip(*BGCchilist)[-1] )
allMinChis = filter( lambda m: m[7] == minChi, BGCchilist)