python: словари списков как-то связаны

Question

Я написал небольшую программу на Python для перебора файла данных ( input_file ) и выполнения вычислений. Если результат вычисления достигает определенных состояний ( stateA или stateB ), информация ( hit ) извлекается из результатов. Хиты для извлечения зависят от параметров из трех наборов параметров.
Я использовал словарь словарей для хранения своих наборов параметров ( param_sets ) и словарь списков для хранения совпадений ( hit ). Словари param_sets и совпадения имеют одинаковые ключи.

Проблема в том,

что списки в словаре совпадений каким-то образом связаны. Когда один список изменяется (вызывая функцию extract_hits ), другие тоже меняются.

Здесь (сокращенный) код:

import os, sys, csv, pdb
from operator import itemgetter

# define three parameter sets
param_sets = {
    'A' : {'MIN_LEN' : 8, 'MAX_X' : 0, 'MAX_Z' : 0},
    'B' : {'MIN_LEN' : 8, 'MAX_X' : 1, 'MAX_Z' : 5},
    'C' : {'MIN_LEN' : 9, 'MAX_X' : 1, 'MAX_Z' : 5}}

# to store hits corresponding to each parameter set
hits = dict.fromkeys(param_sets, [])

# calculations
result = []
for input_values in input_file:
    # do some calculations
    result = do_some_calculations(result, input_values)
    if result == stateA:
        for key in param_sets.keys():
            hits[key] = extract_hits(key, result,
                                                hits[key],
                                                param_sets[key]['MIN_LEN'],
                                                param_sets[key]['MAX_X'],
                                                param_sets[key]['MAX_Z'])
        result = []  # discard results, start empty result list
    elif result == stateB:
        for key in param_sets.keys():
            local_heli[key] = extract_hits(key,
                                           result,
                                           hits[key],
                                           param_sets[key]['MIN_LEN'],
                                           param_sets[key]['MAX_X'],
                                           param_sets[key]['MAX_Z'])
        result = [] # discard results
        result = some_calculation(input_values) # start new result list
    else:
        result = some_other_calculation(result) # append result list



def extract_hits(k, seq, hits, min_len, max_au, max_gu):
    max_len = len(seq)
    for sub_seq_size in reversed(range(min_len, max_len+1)):
        for start_pos in range(0,(max_len-sub_seq_size+1)):
            from_inc = start_pos
            to_exc = start_pos + sub_seq_size
            sub_seq = seq[from_inc:to_exc]
            # complete information about helical fragment sub_seq
            helical_fragment = get_helix_data(sub_seq, max_au, max_gu)
            if helical_fragment:
                hits.append(helical_fragment)
                # search seq regions left and right from sub_seq for further hits
                left_seq = seq[0:from_inc]
                right_seq = seq[to_exc:max_len]
                if len(left_seq) >= min_len:
                    hits = sub_check_helical(left_seq, hits, min_len, max_au, max_gu)
                if len(right_seq) >= min_len:
                    hits = sub_check_helical(right_seq, hits, min_len, max_au, max_gu)
                print 'key', k                 # just for testing purpose
                print 'new', hits              # just for testing purpose
                print 'frag', helical_fragment # just for testing purpose
                pdb.set_trace()                # just for testing purpose
                return hits # appended
    return hits # unchanged

здесь, некоторые выходные данные отладчика Python:

key A
new ['x', 'x', 'x', {'y': 'GGCCGGGCUUGGU'}]
frag {'y': 'GGCCGGGCUUGGU'}
> 
-> return hits
(Pdb) c
key B

new [{'y': 'GGCCGGGCUUGGU'}, {'y': 'CCGGCCCGAGCCG'}]
frag {'y': 'CCGGCCCGAGCCG'}
> extract_hits()
-> return hits
(Pdb) c
key C
new [{'y': 'GGCCGGGCUUGGU'}, {'y': 'CCGGCCCGAGCCG'}, {'y': 'CCGGCCCG'}]
frag {'y': 'CCGGCCCG'}
> extract_hits()
-> return hits

элементы из ключа A не должны присутствовать в ключе B , а элементы из ключа A и ключа B не должны присутствовать в ключ C .

Answer 1

Ваша линия:

hits = dict.fromkeys(param_sets, [])

эквивалентно:

hits = dict()
onelist = []
for k in param_sets:
    hits[k] = onelist

То есть, каждая запись в hits имеет в качестве значения один и тот же объект списка, изначально пустой, независимо от того, какой ключ у него есть. Помните, что присваивание НЕ выполняет неявные копии: скорее, оно присваивает «еще одну ссылку на объект RHS».

То, что вы хотите:

hits = dict()
for k in param_sets:
    hits[k] = []

, то есть, НОВЫЙ И ОТДЕЛЬНЫЙ объект списка в качестве значения каждой записи. Эквивалентное

hits = dict((k, []) for k in param_sets)

Кстати, когда вам do необходимо сделать (неглубокую) копию контейнера, наиболее общий подход обычно заключается в вызове типа контейнера со старым контейнером в качестве аргумента, например: 1018 *

newdict = dict(olddict)
newlist = list(oldlist)
newset = set(oldset)

и т. Д .; это также работает для преобразования контейнеров между типами (newlist = list(oldset) создает список из набора и т. д.).

Answer 2

Словари и списки по умолчанию передаются по ссылке. Для словаря вместо:

hits_old = hits      # just for testing purpose

это будет:

hits_old = hits.copy()      # just for testing purpose

Это скопирует пары ключ / значение словаря, что приведет к эквивалентному словарю, который не будет содержать будущих изменений в словаре совпадений.

Конечно, hit_old во второй функции - это на самом деле список, а не словарь, поэтому вам нужно сделать что-то похожее на следующее, чтобы скопировать его:

hits_old = hits[:]

Понятия не имею, почему списки также не имеют функции copy (), если вам интересно.