我的问题不是关于特定的代码段，而是更一般的，所以请耐心等待：
我应该如何组织我正在分析的数据，以及我应该使用哪些工具来管理它？
我正在使用python和numpy来分析数据。因为python文档表明字典在python中非常优化，并且由于数据本身非常结构化的事实，我将它存储在深层嵌套的字典中。
以下是字典的框架：层次结构中的位置定义元素的性质，每个新行定义先前级别中键的内容：
[AS091209M02] [AS091209M01] [AS090901M06] ...
[100113] [100211] [100128] [100121]
[R16] [R17] [R03] [R15] [R05] [R04] [R07] ...
[1263399103] ...
[ImageSize] [FilePath] [Trials] [Depth] [Frames] [Responses] ...
[N01] [N04] ...
[Sequential] [Randomized]
[Ch1] [Ch2]
编辑：为了更好地解释我的数据集：
[individual] ex: [AS091209M02]
[imaging session (date string)] ex: [100113]
[Region imaged] ex: [R16]
[timestamp of file] ex [1263399103]
[properties of file] ex: [Responses]
[regions of interest in image ] ex [N01]
[format of data] ex [Sequential]
[channel of acquisition: this key indexes an array of values] ex [Ch1]
我执行的操作类型是例如计算数组的属性（在Ch1，Ch2下列出），拾取数组以创建新集合，例如分析给定区域16（R16）中N01的响应个人在不同的时间点等。
这种结构对我来说效果很好，并且非常快，正如所承诺的那样。我可以非常快速地分析完整的数据集（并且字典太小而无法填满我的计算机的ram：半场演出）。
我的问题来自于我需要编写字典操作的繁琐方式。我经常有这样的代码：
for mk in dic.keys():
for rgk in dic[mk].keys():
for nk in dic[mk][rgk].keys():
for ik in dic[mk][rgk][nk].keys():
for ek in dic[mk][rgk][nk][ik].keys():
#do something
这是丑陋，繁琐，不可重复使用和脆弱（需要为字典的任何变体重新编码）。
我尝试使用递归函数，但除了最简单的应用程序之外，我遇到了一些非常讨厌的错误和奇怪的行为导致了大量的时间浪费（这无助于我无法在ipython中使用pdb进行调试当我处理深层嵌套的递归函数时）。最后，我经常使用的唯一递归函数如下：
def dicExplorer(dic, depth = -1, stp = 0):
'''prints the hierarchy of a dictionary.
if depth not specified, will explore all the dictionary
'''
if depth - stp == 0: return
try : list_keys = dic.keys()
except AttributeError: return
stp += 1
for key in list_keys:
else: print '+%s> [\'%s\']' %(stp * '---', key)
dicExplorer(dic[key], depth, stp)
我知道我做错了，因为我的代码很长，很难且不可重用。我需要使用更好的技术来灵活地操作字典，或者将数据放入某种数据库格式（sqlite？）。我的问题是，由于我（非常）在编程方面自学成才，我缺乏实践经验和背景知识来欣赏可用的选项。我已经准备好学习新的工具（SQL，面向对象的编程），无论完成工作需要什么，但我不愿意将我的时间和精力投入到满足我需求的死胡同。
那么您有什么建议来解决这个问题，并能够以更简洁，灵活和可重复使用的方式编写我的工具代码？
附录：除了使用数据字典的特定子词典做某事之外，下面是我为数据集dic实现的操作的一些示例，或者它的子词典：
实际上我有一些运行良好的递归函数：def normalizeSeqDic(dic, norm_dic = {}, legend = ()):
'''returns a normalized dictionary from a seq_amp_dic. Normalization is performed using the first time point as reference
'''
try :
list_keys = dic.keys()
for key in list_keys:
next_legend = legend + (key,)
normalizeSeqDic(dic[key], norm_dic, next_legend)
except AttributeError:
# normalization
# unpack list
mk, ek, nk, tpk = legend
#assign values to amplitude dict
if mk not in norm_dic: norm_dic[mk] = {}
if ek not in norm_dic[mk]: norm_dic[mk][ek] = {}
if nk not in norm_dic[mk][ek]: norm_dic[mk][ek][nk] = {}
if tpk not in norm_dic[mk][ek][nk]: norm_dic[mk][ek][nk][tpk] = {}
new_array = []
for x in range(dic.shape[0]):
new_array.append(dic[x][1:]/dic[x][0])
new_array = asarray(new_array)
norm_dic[mk][ek][nk][tpk] = new_array
return norm_dic
def poolDic(dic):
'''returns a dic in which all the values are pooled, and root (mk) keys are fused
these pooled dics can later be combined into another dic
'''
pooled_dic = {}
for mk in dic.keys():
for ek in dic[mk].keys():
for nk in dic[mk][ek].keys():
for tpk in dic[mk][ek][nk].keys():
#assign values to amplitude dict
if ek not in pooled_dic: pooled_dic[ek] = {}
if nk not in pooled_dic[ek]: pooled_dic[ek][nk] = {}
if tpk not in pooled_dic[ek][nk]:
pooled_dic[ek][nk][tpk] = dic[mk][ek][nk][tpk]
else: pooled_dic[ek][nk][tpk]= vstack((pooled_dic[ek][nk][tpk], dic[mk][ek][nk][tpk]))
return pooled_dic
def timePointsDic(dic):
'''Determines the timepoints for each individual key at root
'''
tp_dic = {}
for mk in dic.keys():
tp_list = []
for rgk in dic[mk].keys():
tp_list.extend(dic[mk][rgk]['Neuropil'].keys())
tp_dic[mk]=tuple(sorted(list(set(tp_list))))
return tp_dic
对于某些操作，我发现除了压扁词典之外别无他法：
def flattenDic(dic, label):
'''flattens a dic to produce a list of of tuples containing keys and 'label' values
'''
flat_list = []
for mk in dic.keys():
for rgk in dic[mk].keys():
for nk in dic[mk][rgk].keys():
for ik in dic[mk][rgk][nk].keys():
for ek in dic[mk][rgk][nk][ik].keys():
flat_list.append((mk, rgk, nk, ik, ek, dic[mk][rgk][nk][ik][ek][label])
return flat_list
def extractDataSequencePoints(flat_list, mk, nk, tp_list):
'''produces a list containing arrays of time point values
time_points is a list of the time points wished (can have 2 or 3 elements)
'''
nb_tp = len(tp_list)
# build tp_seq list
tp_seq = []
tp1, tp2, tp3 = [], [], []
if nk == 'Neuropil':
tp1.extend(x for x in flat_list if x[0]==mk and x[2] == 'Neuropil' and x[3] == tp_list[0])
tp2.extend(x for x in flat_list if x[0]==mk and x[2] == 'Neuropil'and x[3] == tp_list[1])
else:
tp1.extend(x for x in flat_list if x[0]==mk and x[2] != 'Neuropil'and x[3] == tp_list[0])
tp2.extend(x for x in flat_list if x[0]==mk and x[2] != 'Neuropil'and x[3] == tp_list[1])
if nb_tp == 3:
if nk == 'Neuropil':
tp3.extend(x for x in flat_list if x[0]==mk and x[2] == 'Neuropil'and x[3] == tp_list[2])
else:
tp3.extend(x for x in flat_list if x[0]==mk and x[2] != 'Neuropil'and x[3] == tp_list[2])
for x in tp1:
for y in tp2:
if x[0:3] == y[0:3] :
if nb_tp == 3:
for z in tp3:
if x[0:3] == z[0:3] :
tp_seq.append(asarray([x[4],y[4],z[4]]))
else:
tp_seq.append(asarray([x[4],y[4]]))
return tp_seq
答案 0 :(得分：12)
“我将它存储在深层嵌套的字典中”
而且，正如你所见，它并没有很好地发挥作用。
有什么替代方案？
复合键和浅字典。你有一个8部分的钥匙： （个人，成像会话，区域成像，文件时间戳，文件属性，图像中感兴趣区域，数据格式，获取通道）哪些映射 一系列价值观。
{ ('AS091209M02', '100113', 'R16', '1263399103', 'Responses', 'N01', 'Sequential', 'Ch1' ): array,
...
这个问题是搜索。
适当的班级结构。实际上，完整的类定义可能有点矫枉过正。
“我执行的操作类型是例如计算数组的属性 （在Ch1，Ch2下列出），拿起阵列来制作新的集合，例如分析 来自不同时间点的给定个体的区域16（R16）的N01的响应等。“
<强>建议
首先，使用namedtuple作为最终对象。
Array = namedtuple( 'Array', 'individual, session, region, timestamp, properties, roi, format, channel, data' )
或类似的东西。构建这些命名元组对象的简单列表。然后，您可以简单地迭代它们。
其次，在这个数组对象的主列表上使用许多简单的map-reduce操作。
过滤
for a in theMasterArrrayList:
if a.region = 'R16' and interest = 'N01':
# do something on these items only.
按公钥减少：
individual_dict = defaultdict(list)
for a in theMasterArrayList:
individual_dict[ a.individual ].append( a )
这将在地图中创建一个具有您想要的项目的子集。
然后你可以做indiidual_dict ['AS091209M02']并拥有他们的所有数据。您可以为任何（或所有）可用密钥执行此操作。
region_dict = defaultdict(list)
for a in theMasterArrayList:
region_dict[ a.region ].append( a )
这不会复制任何数据。它内存速度快，相对紧凑。
映射（或转换）数组：
for a in theMasterArrayList:
someTransformationFunction( a.data )
如果数组本身就是一个列表，那么你可以更新该列表而不会破坏整个元组。如果需要从现有数组创建新数组，则需要创建新元组。这没什么不对，但它是一个新的元组。你最终得到这样的程序。
def region_filter( array_list, region_set ):
for a in array_list:
if a.region in region_set:
yield a
def array_map( array_list, someConstant ):
for a in array_list:
yield Array( *(a[:8] + (someTranformation( a.data, someConstant ),) )
def some_result( array_list, region, someConstant ):
for a in array_map( region_filter( array_list, region ), someConstant ):
yield a
您可以构建转换，缩减，映射到更复杂的事物。
最重要的是从主列表中仅创建所需的词典，这样就不会进行任何超出最低限度的过滤。
顺便说一句。这可以简单地映射到关系数据库。它会慢一些，但您可以进行多个并发更新操作。除了多个并发更新外，关系数据库不提供任何高于此的功能。
答案 1 :(得分：2)
您可以通过替换以下内容使循环看起来更好：
for mk in dic.keys():
for rgk in dic[mk].keys():
for nk in dic[mk][rgk].keys():
for ik in dic[mk][rgk][nk].keys():
for ek in dic[mk][rgk][nk][ik].keys():
#do something
与
for mv in dic.values():
for rgv in mv.values():
for nv in rgv.values():
for iv in nv.values():
for ev in iv.values():
#do something
因此，您可以使用相对简洁的代码访问所有值。如果您还需要一些按键，可以执行以下操作：
for (mk, mv) in dic.items():
# etc.
根据您的需要，您可能还会考虑创建然后使用带有元组键的单个字典：
dic[(mk, rgk, nv, ik, ek)]
答案 2 :(得分：1)
我将分享一些关于此的想法。而不是这个功能：
for mk in dic.keys():
for rgk in dic[mk].keys():
for nk in dic[mk][rgk].keys():
for ik in dic[mk][rgk][nk].keys():
for ek in dic[mk][rgk][nk][ik].keys():
#do something
您想简单地写为：
for ek in deep_loop(dic):
do_something
有两种方法。一个是功能性的，第二个是发电机状的。第二个是：
def deep_loop(dic):
for mk in dic.keys():
for rgk in dic[mk].keys():
for nk in dic[mk][rgk].keys():
for ik in dic[mk][rgk][nk].keys():
for ek in dic[mk][rgk][nk][ik].keys():
yield ek
这允许您捕获通过字典的逻辑。修改此功能非常容易，以支持不同的结构方式。这取决于你的结构改变的方式，如果它只是一个循环的深度或不同的东西。您是否可以发布一些更高级的示例，说明您通过树的要求是什么？喜欢过滤，搜索等？深度看起来像这样（未经测试） - 它将产生一对（元组的键），（值）：
def deep_loop(dic, depth):
if depth == 0:
yield (), dic
for subkey, subval in dic.items():
for ktuple, value in deep_loop(subval, depth-1):
yield (subkey,)+ktuple, value
现在变得更容易了：
for (k1,k2,k3,k4), value in deep_loop(dic, 4):
# do something
还有其他方法可以自定义此方法，您可以添加一个命名的元组类型作为deep_loop的参数。 Deep_loop可以自动检测命名元组的深度并返回命名元组。
答案 3 :(得分：0)
您问：我应该如何组织我正在分析的数据，以及我应该使用哪些工具来管理它？
我怀疑字典对于它的所有优化都不是这个问题的正确答案。我认为你最好使用XML，或者如果有Python绑定，HDF5，甚至NetCDF。或者，正如您自己建议的那样，数据库。
如果你的项目有足够的持续时间和有用性来保证学习如何使用这些技术，那么我认为你会发现现在学习它们并获得正确的数据结构是比通过错误的数据摔跤更好的途径整个项目的结构。学习XML，或HDF5，或者您选择的任何东西，都在积累您的一般专业知识，使您能够更好地处理下一个项目。坚持使用笨拙，特定于问题和特殊的数据结构会导致下一次出现同样的问题。
答案 4 :(得分：0)
您可以编写一个生成器函数，允许您迭代某个级别的所有元素：
def elementsAt(dic, level):
if not hasattr(dic, 'itervalues'):
return
for element in dic.itervalues():
if level == 0:
yield element
else:
for subelement in elementsAt(element, level - 1):
yield subelement
然后可以使用以下内容：
for element in elementsAt(dic, 4):
# Do something with element
如果你还需要过滤元素，你可以先得到所有需要过滤的元素（比如'rgk'级别）：
for rgk in getElementsAt(dic, 1):
if isValid(rgk):
for ek in getElementsAt(rgk, 2):
# Do something with ek
至少可以使用词典层次结构更容易一些。使用更具描述性的名称也会有所帮助。