Каковы эффективные методы для гибко справляться с глубоко вложенными данными? ⇐ Python

[Anonymous]

Мой вопрос не о конкретном фрагменте кода, а более общий, поэтому, пожалуйста, терпите меня: < /p>

Как мне организовать данные, которые я анализирую, и какие инструменты мне следует использовать для анализа данных? Поскольку документация по Python указывает на то, что словаря очень оптимизированы в Python, а также из -за того, что сами данные очень структурированы, я сохранил его в глубоко вложенном словаре. Уровень: < /p>

[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]
< /code>

Изменить: чтобы объяснить немного лучше мой набор данных: < /p>

[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]
< /code>

Тип операций, которые я выполняю, - это, например, для вычисления свойств массивов (перечисленных в разделе CH1, CH2), забирайте массивы, чтобы сделать новую коллекцию, например, анализировать ответы N01 из региона 16 (R16) с данным индивидуальным моментам в разные моменты времени, и т. Д. < /p>

, эта структура, это очень много, и это очень много, и это очень многому, и это очень многому, и это многомументовано, и это очень много, и это очень много, и это многомуподобилось. Я могу довольно быстро проанализировать полный набор данных (и словарь слишком мал, чтобы заполнить оперативную память моего компьютера: половина концерта). < /P>

Моя проблема возникает из -за громоздкого способа, в которой мне нужно запрограммировать операции словаря. У меня часто есть участки кода, которые идут так: < /p>

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
< /code>

, который является уродливым, громоздким, неофилированным и хрупким (необходимо перекодировать его для любого варианта словаря). < /p>

Я пытался использовать рекурсивные функции, но, по сравнению с самыми простыми приложениями, я сталкивался с некоторыми очень неприятными ошибками, и это не потеряет, что не потеряет, что не потеряет, что не потеряет, что не потеряет, что не потеряет, что не потеряет, что не потеряет. С PDB в IPTHON, когда я имею дело с глубоко вложенными рекурсивными функциями). В конце концов, единственная рекурсивная функция, которую я использую регулярно, - это следующее: < /p>

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)
< /code>

Я знаю, что делаю это неправильно, потому что мой код длинный, лапь и не повторно. Мне нужно либо использовать лучшие методы для гибкой манипулирования словарями, либо для размещения данных в какой -то формате базы данных (SQLite?). Моя проблема в том, что, поскольку я (плохо) самоучка в отношении программирования, мне не хватает практического опыта и фоновых знаний, чтобы оценить доступные варианты. Я готов изучить новые инструменты (SQL, объектно-ориентированное программирование), все, что нужно, чтобы выполнить работу, но я неохотно вкладываю свое время и усилия в нечто, что будет тупиком для моих нужд. Помимо того, что что-то делает с конкретным поддикциором словаря данных, вот несколько примеров операций, которые я реализовал для набора данных DIC, или в его словарке: < /p>

На самом деле у меня есть некоторые рекурсивные функции, которые работали хорошо: < /p>

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
< /code>

Для некоторых операций я не нашел другого способа, кроме как сгладить словарь: < /p>

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


Подробнее здесь: https://stackoverflow.com/questions/254 ... xible-mann